diff --git a/.gitignore b/.gitignore
index bafd54a5..78983498 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,6 +38,21 @@ sbom-server.json
 htmlcov/
 .pytest_cache/
 
+# Local UAT evidence. Keep compact manifests/results/draft issue summaries
+# visible for selective review, but never offer raw household media, event
+# streams, health snapshots, or container logs for an accidental commit.
+/uat-sessions/**/video/
+/uat-sessions/**/clips/
+/uat-sessions/**/logs/
+/uat-sessions/**/ndjson/
+/uat-sessions/**/snapshots/
+
+# Generated audit/session outputs. These can contain machine-local paths,
+# prompts, or deployment observations; regenerate or curate before publishing.
+/AUDIT-REPORT.md
+/audit-draft-issues.md
+/pi-session-*.html
+
 # Frontend build deps for the dashboard's vendored Tailwind bundle.
 # package.json + tailwind.config.js are committed; build artifacts and
 # the npm install state are not. Re-run `npm install && npm run build:css`
diff --git a/:memory:.ses b/:memory:.ses
new file mode 100644
index 00000000..8e2bcfa4
--- /dev/null
+++ b/:memory:.ses
@@ -0,0 +1,2 @@
+1789215087076
+80298cc7-4cef-98c0-2eea-5f395ca28db5
diff --git a/AUDIT-REPORT.md b/AUDIT-REPORT.md
new file mode 100644
index 00000000..56f6da47
--- /dev/null
+++ b/AUDIT-REPORT.md
@@ -0,0 +1,1286 @@
+# dotty-stackchan — Project-Wide Audit Report
+
+## Executive summary
+
+This audit covered the full `dotty-stackchan` stack — the four server-side containers (xiaozhi-server, dotty-pi, dotty-behaviour, bridge dashboard), the xiaozhi-server drop-in patches, the ASR/TTS providers, the voice LLM providers, the dotty-pi-ext voice tools, the StackChan ESP32-S3 firmware, the top-level scripts, the docs, the monitoring assets, the shipped compose templates, the open GitHub issues, and the open PRs.
+
+**282 findings** were reported: **4 critical, 24 high, 114 medium, 125 low, 15 info**. By kind: **157 bugs, 47 doc, 44 quality, 19 PR reviews, 15 issue triages**. Four false positives were rejected during verification.
+
+**Headline risks:**
+
+1. **A remote-LAN → docker-host-root exploit chain (G9, critical).** Unauthenticated `/xiaozhi/admin/*` routes on a `0.0.0.0:8003` listener + a `/var/run/docker.sock` mount in the same container + host networking on the other three services compose into a single hop from LAN to host root. The individually-reported symptoms (unauth admin routes F16, arbitrary-path play-asset G10, all-root containers G11) are each one link of this chain.
+2. **PR #141 is a personal de-safety fork mislabeled as a bug fix (F120–F124, two critical).** It blanks the kid-mode/safety turn suffix, drops all system messages, disables the perception relay, and adds an explicit-sexual-content persona with hardcoded PII to a repo whose default audience is children. **It must be closed, not merged.**
+3. **The shipped all-in-one compose is structurally broken (G18, G19, critical/high).** `compose.all-in-one.yml` omits the docker.sock mount the default `PiVoiceLLM` provider requires and the xiaozhi-patches mounts the entire behaviour layer depends on — a fresh deploy following its own Quick start gets a non-functional voice path.
+4. **Kid-safety guardrails are thinner than the docs imply.** There is no output content filter on any live path (#138 still open); `memory_lookup` can surface unreviewed `person_pending` minor facts (F251); and the dashboard `say`/`start-story` ingresses bypass filtering entirely (F186).
+
+## How this was produced
+
+Multi-agent adversarial audit of the whole repository: parallel area specialists, **3 deepen rounds** to chase compound/cross-file issues, **3-vote adversarial verification** (3 independent lenses per finding), and a completeness critic that swept files never targeted as primary audit areas (monitoring assets, compose templates, the emoji→firmware contract, the vendored `firmware/server/` tree).
+
+**Caps hit:** verification was capped at **50 of 172 qualifying findings**; the lowest-severity overflow is reported **unverified**. Critical/high findings were prioritized for the 3-lens treatment. Where a finding shows "confirmed N/3 lenses" it was multi-vote verified; "confirmed 1/1 lenses" is a single completeness-critic confirmation; "unverified — over cap" / "low-sev, unverified" means it was reported but not put through the multi-vote gate.
+
+---
+
+## gap: Container privilege/trust boundary (docker.sock + host networking)
+
+### [CRITICAL] Remote-LAN → docker-host-root exploit chain
+**File:** `docker-compose.yml.template` (compose 43-60, 596) + `custom-providers/xiaozhi-patches/http_server.py` (596, 620-672)
+**Issue:** The four-container trust boundary collapses into one exploitable chain. xiaozhi-server binds `0.0.0.0:8003` and registers all 11 `/xiaozhi/admin/*` routes with no auth; the same container mounts `/var/run/docker.sock` + `/usr/bin/docker` (the compose comment itself admits this gives "effective root on the docker host"); the other three services run `network_mode: host` with no segmentation; none of the four Dockerfiles set `USER`, so every container is root. An attacker on the LAN/Tailnet has a confirmed write primitive into the socket-holding root container.
+**Fix:** Break the chain at >1 link: (1) replace the raw docker.sock with a least-privilege `docker-socket-proxy` exposing only `exec`; (2) add a shared-secret bearer-token aiohttp middleware over `/xiaozhi/admin/*`; (3) bind admin HTTP to `127.0.0.1` and reach it only from sibling containers on loopback; (4) add non-root `USER` to all four Dockerfiles. Do at least the socket-proxy + route auth.
+**Verification:** confirmed 1/3 lenses (completeness critic; compound finding assembled from confirmed symptoms).
+
+### [HIGH] play-asset accepts arbitrary absolute filesystem path with no allowlist
+**File:** `custom-providers/xiaozhi-patches/http_server.py:376-411`
+**Issue:** `/xiaozhi/admin/play-asset` reads `asset` as a raw absolute path; the only validation is `os.path.exists`, then it is handed to `AudioSegment.from_file` (ffmpeg). The sibling `songs` handler hard-codes a base dir + extension allowlist — play-asset has neither. An unauthenticated LAN caller can point ffmpeg at any readable file (existence-probe via 404-vs-200, exercise libav demuxer CVEs) inside the docker.sock-holding container.
+**Fix:** `os.path.realpath(asset)` must start with the canonical songs base before any decode; enforce the `{opus,ogg,wav,mp3}` allowlist; prefer accepting only a basename joined onto the fixed base.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] All four containers run as root (no USER directive)
+**File:** `Dockerfile`, `dotty-pi/Dockerfile`, `dotty-behaviour/Dockerfile`, `bridge/Dockerfile`
+**Issue:** None of the four images declare `USER`. For xiaozhi-server the root process is the one mounting docker.sock, so any code-exec bug there is already host root. The FastAPI/uvicorn and pi workloads do not need root.
+**Fix:** Add a non-root `USER` to each Dockerfile (create app user, chown state dirs). Pair with `no-new-privileges:true` and read-only rootfs where feasible; run the socket-proxy so root-in-container is no longer root-on-host.
+**Verification:** confirmed 1/1 lenses.
+
+### [MEDIUM] Host networking removes network segmentation
+**File:** `dotty-pi/docker-compose.yml:17`, `dotty-behaviour/docker-compose.yml:23`, `bridge/docker-compose.yml:31`
+**Issue:** Three of four services use `network_mode: host`, so their listeners bind every interface with no bridge isolation and a compromise of any one has unrestricted loopback access to every host service. This is the segmentation half of why the chain finding is critical rather than contained.
+**Fix:** Where loopback-to-llama-swap is the only reason for host mode, use a shared user-defined bridge network instead; bind behaviour/bridge to `127.0.0.1` if callers are host-local; at minimum document the host-networking decision as an explicitly accepted risk.
+**Verification:** low-sev, unverified.
+
+---
+
+## gap: Shipped compose templates & .env.example (config-drift surface)
+
+### [CRITICAL] compose.all-in-one.yml omits the docker.sock + docker CLI mounts PiVoiceLLM requires
+**File:** `compose.all-in-one.yml:64-79`
+**Issue:** The shipped config defaults to `selected_module.LLM: PiVoiceLLM`, which reaches the brain via `docker exec -i dotty-pi pi`. That needs the host docker socket + docker CLI bind-mounted (provided by `docker-compose.yml.template:59-60`). compose.all-in-one.yml mounts the provider dir but NOT the socket or binary — so a new user following the file's own Quick start with the default config gets a container that cannot exec into dotty-pi, and every voice turn fails. The file's own header even says PiVoiceLLM "requires the host docker socket" but never mounts it.
+**Fix:** Add the two PiVoiceLLM mounts to compose.all-in-one.yml. Or, if all-in-one is meant to be OpenAICompat-only, change the shipped `selected_module` default and say so in the header.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] compose.all-in-one.yml is missing the xiaozhi-patches mounts
+**File:** `compose.all-in-one.yml:64-79`
+**Issue:** The canonical template mounts `portal_bridge.py`, `websocket_server.py`, `http_server.py`, and `textMessageHandlerRegistry.py` (admin routes, active_connections registry, perception relay). all-in-one mounts none of them, so a user deploying with this file gets upstream xiaozhi-server with no admin portal and no perception relay — the entire dotty-behaviour layer is inert (consumers fire into 404s). Also missing vs the template: openai_compat, personas, receiveAudioHandle.py, dances.py, textUtils.py, songs, and the kid/smart state mount.
+**Fix:** Bring the volume list to parity with `docker-compose.yml.template`, or generate the all-in-one from the template so it can't drift.
+**Verification:** confirmed 1/1 lenses.
+
+### [MEDIUM] compose.all-in-one.yml never sets VISION_BRIDGE_URL/BRIDGE_URL
+**File:** `compose.all-in-one.yml:56-58`
+**Issue:** The relay resolves its target from `BRIDGE_URL`/`VISION_BRIDGE_URL`; with neither set it logs "dropping perception event" and returns. all-in-one's environment block sets only `TZ`, so even if the relay handler were mounted, every perception event would be dropped.
+**Fix:** Add `VISION_BRIDGE_URL=http://<host-LAN-IP>:8090` (document `BRIDGE_URL` as its alias) alongside mounting the relay handler.
+**Verification:** confirmed 1/1 lenses.
+
+### [MEDIUM] .env.example omits load-bearing xiaozhi-server vars
+**File:** `.env.example:4-21`
+**Issue:** Several vars the template declares and the code reads are absent: `VISION_BRIDGE_URL`, `DOTTY_KID_MODE_STATE`, `DOTTY_SMART_MODE_STATE`, `DOTTY_STATE_DIR`, `DOTTY_PI_CONTAINER`, `DOTTY_PI_EXTRA_FLAGS`. The state-dir/kid-mode ones desync the firmware LED pips from the dashboard if left at the dead default.
+**Fix:** Add the missing vars with the same explanatory comments already in `docker-compose.yml.template`.
+**Verification:** low-sev, unverified.
+
+### [LOW] Dead '/root/zeroclaw-bridge default' fallback comment in template
+**File:** `docker-compose.yml.template:38-40`
+**Issue:** The comment warns the reader "falls through to the dead /root/zeroclaw-bridge default"; the real defaults are `/var/lib/dotty-bridge/state/{kid,smart}-mode`. ZeroClaw was retired in #36.
+**Fix:** Rewrite the comment to state the real default; grep for other zeroclaw/RPi residue.
+**Verification:** low-sev, unverified.
+
+### [LOW] .env.example documents many dotty-behaviour vars but not SOUND_TURN_YAW_DEG
+**File:** `.env.example:23-153`
+**Issue:** The file mixes xiaozhi-server and dotty-behaviour vars; `SOUND_TURN_YAW_DEG` (read at `dotty-behaviour/config.py:105`) is absent while sibling perception vars are documented — arbitrary coverage that obscures which container consumes each var.
+**Fix:** Split into a per-service `.env.example`, or section-label each block by consuming container; add `SOUND_TURN_YAW_DEG`.
+**Verification:** low-sev, unverified.
+
+---
+
+## PR #141
+
+### [CRITICAL] #141 is a personal de-safety fork, not a bug fix — close
+**File:** PR #141
+**Issue:** The title claims to fix kid-mode constraints and system-prompt leakage; the diff does the opposite — it (a) blanks the safety/format suffix (`_TURN_SUFFIX = ""`), (b) drops all system messages, (c) comments out the perception relay + room_view capture, (d) adds `personas/sweetheart.md`, an explicit-sexual-content persona with the author's hardcoded PII. None is gated, tested, or documented; all of it contradicts the repo's stated kid-safe scope (ages 4-8).
+**Fix:** **Close the PR.** Extract only the legitimate piper emoji-strip into a standalone PR. Ask the author to keep the persona, prompt-stripping, and perception-disabling on a private fork.
+**Verification:** confirmed 3/3 lenses.
+
+### [CRITICAL] _TURN_SUFFIX blanked — disables English-only, emoji-prefix, length AND kid-safety constraints
+**File:** `custom-providers/openai_compat/openai_compat.py:28`
+**Issue:** `_TURN_SUFFIX = build_turn_suffix(KID_MODE)` is replaced with `_TURN_SUFFIX = ""`, stripping the full HARD-CONSTRAINTS block: English-only, the mandatory single-emoji prefix contract, length/no-Markdown rules, AND the entire kid-mode topic blocklist plus jailbreak resistance. `build_turn_suffix` is now dead while still imported.
+**Fix:** Revert to `_TURN_SUFFIX = build_turn_suffix(KID_MODE)`. If the suffix was leaking into TTS, fix the echo, do not delete the contract.
+**Verification:** confirmed 3/3 lenses.
+
+### [HIGH] All system messages dropped from dialogue
+**File:** `custom-providers/openai_compat/openai_compat.py:108-109`
+**Issue:** `if role == "system": continue` skips every system message, removing the top-level `.config.yaml` `prompt:` safety/emoji layer (one of the two load-bearing layers per CLAUDE.md). The title calls this fixing "system prompt leakage"; it deletes the system prompt.
+**Fix:** Remove the block. If one system message was being spoken, filter that source specifically.
+**Verification:** confirmed 3/3 lenses.
+
+### [HIGH] Perception event relay and room_view capture disabled by commenting out _spawn calls
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:153-156, 193`
+**Issue:** Both the room_view background capture and the perception-event POST to dotty-behaviour are commented out, silently disabling the entire perception bus relay and the room_view VLM identity feature, leaving dead scaffolding. Looks like personal-fork debugging left in.
+**Fix:** Revert both comment-outs. Disable a misbehaving consumer in dotty-behaviour config instead of severing the relay.
+**Verification:** confirmed 2/3 lenses.
+
+### [HIGH] sweetheart.md adds NSFW persona with hardcoded PII to a kid-safe public repo
+**File:** `personas/sweetheart.md:1-23`
+**Issue:** New persona instructs "flirty"/"sexually explicit stories with detail" and hardcodes the author's real profile. Contradicts `personas/default.md` (ages 4-8, no romantic/adult topics), omits the mandatory emoji-prefix contract, and uses gemma chat-template tags that aren't this repo's persona format. PII + explicit content in a public repo is a privacy and content-safety regression.
+**Fix:** Do not merge; remove the file. A personal/adult persona belongs on a private fork.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] Full conversation (system+user messages) logged at info level — privacy/PII regression
+**File:** `custom-providers/openai_compat/openai_compat.py:150`
+**Issue:** `logger.info(f"Sending messages to LLM: {json.dumps(messages,...)}")` dumps persona, system prompt, and every user utterance to persistent docker logs on every turn — including anything a child says. Reads as leftover debugging.
+**Fix:** Remove the line, or gate behind a debug flag at DEBUG level with contents redacted.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] dotty-behaviour env toggles added with no code/doc reference
+**File:** `dotty-behaviour/docker-compose.yml:49-50`
+**Issue:** `SOUND_TURN_YAW_DEG=20` / `WAKE_TURN_YAW_DEG=20` added with no consumer change, no docs, no indication they're honored. Dead config if unread; incomplete if read. Also muddies the PR scope.
+**Fix:** Confirm the consumers read them; if so ship the consumer code + doc and split into its own PR. If not, drop the lines.
+**Verification:** unverified — over cap.
+
+### [LOW] piper emoji/non-speakable strip is the one reasonable change but is bundled and untested
+**File:** `custom-providers/piper_local/piper_local.py:137-140`
+**Issue:** Stripping emoji/non-Latin codepoints before Piper synth is defensible, but the regex also strips CJK with no log, has no test, and is bundled into an un-mergeable PR. An all-emoji utterance produces silence with no log.
+**Fix:** If salvaged into a standalone PR: add tests for emoji-only/CJK inputs and log at debug when a chunk is fully stripped.
+**Verification:** unverified — over cap.
+
+---
+
+## xiaozhi-server drop-in patches (http/ws/ota/admin routes)
+
+### [HIGH] All /xiaozhi/admin/* routes are completely unauthenticated
+**File:** `custom-providers/xiaozhi-patches/http_server.py:620-672` (handlers 34-589)
+**Issue:** Every admin endpoint (inject-text, abort, set-head-angles, set-state, set-toggle, set-face-identified, take-photo, play-asset, songs, say, devices) is registered with no auth check, while OTA and WS paths guard themselves. Anyone reaching port 8003 can make the robot speak arbitrary text, move, change state, trigger the camera, and (play-asset) read any absolute path. inject-text is a remote prompt-injection vector into the pi agent.
+**Fix:** Gate the routes behind a shared secret (Bearer / `X-Admin-Token` aiohttp middleware, 401 otherwise). At minimum confine play-asset to an allow-listed base via realpath+startswith.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] face_detected during talk state silently drops the bridge perception relay
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:134-138`
+**Issue:** The `face_detected`/`talk` branch does an early `return` that also skips the relay POST at the bottom of `handle()`. The talk-gate's intent is only to suppress re-triggering room_view capture, not forwarding to dotty-behaviour, so consumers desync for the duration of a conversation.
+**Fix:** Wrap only the capture kick-off in `if cstate != 'talk':` and fall through to the relay.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] face_lost does not reset _room_description_in_flight, can wedge room_view capture
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:92-102, 139-141`
+**Issue:** `face_lost` clears the room-view caches but not `_room_description_in_flight`. If a capture task crashed without clearing the flag, every subsequent `face_detected` refuses to re-capture for the life of the connection.
+**Fix:** Also set `conn._room_description_in_flight = False` in the `face_lost` branch.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] WebSocket close uses removed `closed` attribute on modern websockets
+**File:** `custom-providers/xiaozhi-patches/websocket_server.py:143-151`
+**Issue:** The finally block checks `hasattr(websocket,'closed')` — gone in the `ServerConnection` API this code targets — so the branch is dead and the guard is largely pointless.
+**Fix:** Drop the `closed` branch; rely on `getattr(websocket,'state',None)` or a try/except `await websocket.close()`.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Query-param device-id can bypass token auth via the allowlist short-circuit
+**File:** `custom-providers/xiaozhi-patches/websocket_server.py:84-108`
+**Issue:** Query params are injected into `request.headers` and read back by `_handle_auth`; a `?device-id=<allowed-device>` is trusted by the `allowed_devices` whitelist the same as a header, letting a client skip token verification. Headers mutation semantics are also version-fragile.
+**Fix:** Treat query-param identity as untrusted — do not let a query-string device-id satisfy the allowlist bypass; use a separate dict rather than mutating `request.headers`.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] OTA _is_higher_version treats pre-release/build-suffix versions as newer
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:24-43, 315`
+**Issue:** `_parse_version` does `re.findall(r'\d+', ver)`, so `1.2.3-rc1 → (1,2,3,1)` compares greater than GA `(1,2,3)`, and `1.2` equals `1.2.0`. A device on GA is offered a stale rc; build-suffix versions invert ordering. Verified: `_is_higher_version('1.2.3-rc1','1.2.3')` returns True.
+**Fix:** Use a real semver-ish compare (strip leading `v`, parse the numeric core, rank pre-release suffixes BELOW the release, consider only the first 3 segments). Add unit tests for rc/build cases.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] play-asset clobbers conn.client_abort / client_is_speaking, corrupting a concurrent voice turn
+**File:** `custom-providers/xiaozhi-patches/http_server.py:452-453, 474`
+**Issue:** `_dispatch()` unconditionally sets `conn.client_abort=False` then `conn.client_is_speaking=True`, with a finally that marks idle. play-asset is timer-driven on the "first available device", so a play-asset landing mid-turn cancels a user's barge-in and marks the device idle while chat TTS streams.
+**Fix:** Refuse with 409 if the conn is mid-turn; save/restore prior flags, or route admin audio through the TTS-priority queue.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] Admin handlers call conn.websocket.send() concurrently with the chat-path writer
+**File:** `custom-providers/xiaozhi-patches/http_server.py:146, 194, 242, 288, 338, 456-468`
+**Issue:** Fire-and-forget `_spawn(conn.websocket.send(...))` admin sends run concurrently with xiaozhi's own send on the same `ServerConnection`. The websockets library forbids interleaved sends; a `ConcurrencyError` is swallowed by the spawned task and the chat frame can be corrupted. play-asset (hundreds of opus frames) maximizes overlap.
+**Fix:** Serialize device-bound writes through a per-conn `asyncio.Lock`; at minimum log the `ConcurrencyError` and gate play-asset behind an idle check.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] _dotty_say mutates conn.sentence_id from a worker thread, racing the consumer and pre-empting chat TTS
+**File:** `custom-providers/xiaozhi-patches/http_server.py:547-574, 582`
+**Issue:** `_enqueue()` runs on a thread and sets `conn.sentence_id` with no busy-check or lock; the greeter fires on perception events that can coincide with a live conversation, so a `/say` mid-turn overwrites `sentence_id` and the consumer drops the chat turn's remaining sentences. Also no `tts_text_queue` guard.
+**Fix:** Refuse `/say` with 409 when mid-turn; guard for `tts_text_queue`; set `sentence_id` on the loop thread.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] play-asset omits the tts 'start' lifecycle frame and uses an unvalidated Opus rate
+**File:** `custom-providers/xiaozhi-patches/http_server.py:414, 421-423, 456-461`
+**Issue:** Playback never sends `{type:tts,state:start}` (firmware-fragile), and feeds `conn.sample_rate` straight into the Opus encoder without checking it is in `{8000,12000,16000,24000,48000}`; a non-legal rate raises, is swallowed by the broad except, and the endpoint still returns 200.
+**Fix:** Emit the full lifecycle; validate/resample the rate; propagate decode failure as 500.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] EventTextMessageHandler relays perception events to a stale BRIDGE_URL
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:67-78, 178`
+**Issue:** Events POST to `{BRIDGE_URL or VISION_BRIDGE_URL}/api/perception/event`, but the bus moved to dotty-behaviour (:8090) in #115. If the deploy sets only a behaviour URL var, or BRIDGE_URL points at the dashboard container (which no longer serves that route), every event 404s and is dropped — silently disabling face_greeter/sound_turner/state gating.
+**Fix:** Rename/select the var to point at dotty-behaviour explicitly and update the warning text; verify the deploy compose sets the var the handler reads.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] state_changed/face_detected ordering can corrupt the room_view gate
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:109-115, 133-138`
+**Issue:** The room_view gate reads `conn.current_state`, set from `state_changed`. If the firmware emits `face_detected` before the IDLE→TALK `state_changed` it acted on, the gate sees `idle` and fires a capture for a mid-talk flicker — the "stacked Hi NAME" failure the comment claims to prevent.
+**Fix:** Gate on a positive "room_view already captured this session" flag rather than `current_state`, or have firmware stamp `face_detected` with its state.
+**Verification:** unverified — over cap.
+
+### [LOW] OTAHandler.handle_post finally-block can swallow a secondary exception
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:359-361`
+**Issue:** Unlike `handle_download`, `handle_post`'s finally calls `_add_cors_headers` with no try/except and a bare `return` that masks a propagating exception; an edge case 500s the device with non-JSON.
+**Fix:** Wrap `_add_cors_headers` in try/except; initialize `response = None` and short-circuit.
+**Verification:** unverified — over cap.
+
+### [LOW] _dotty_inject_text reads conn.headers without the 'or {}' guard used elsewhere
+**File:** `custom-providers/xiaozhi-patches/http_server.py:66`
+**Issue:** Line 66 lacks the `(getattr(conn,'headers',{}) or {})` guard every sibling handler uses; if `conn.headers` is None during teardown, inject-text raises after already dispatching chat, returning a misleading 500.
+**Fix:** Apply the same guard on line 66.
+**Verification:** unverified — over cap.
+
+### [LOW] OTA mqtt branch ships an empty-password block with no websocket fallback
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:260-279`
+**Issue:** When mqtt_gateway is set but the signature key is missing/fails, the handler sends an mqtt block with `password:""` and (being exclusive with the websocket else) no fallback — the device gets a config it cannot authenticate with.
+**Fix:** Fall back to the websocket block (or return an error) when the signature is unavailable.
+**Verification:** unverified — over cap.
+
+### [LOW] OTA model-name matching is brittle — updates silently never offered
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:84-90, 200-201, 304`
+**Issue:** `files_by_model.get(device_model, [])` requires an exact match between the firmware-reported model and the operator's bin-filename prefix, which rarely align; the device is silently told it's up-to-date and the same log fires for both "unknown model" and "already latest".
+**Fix:** Log the parsed model + known keys when candidates is empty; allow a configured fallback bucket or case-insensitive match; distinct log lines for the two cases.
+**Verification:** unverified — over cap.
+
+### [LOW] OTA timezone_offset / firmware_cache_ttl assume numeric YAML
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:62, 226`
+**Issue:** `timezone_offset * 60` on a quoted `"8"` yields a 60-copy string in the OTA payload; a non-int ttl makes `int(...)` raise.
+**Fix:** Coerce with `int(...)` and validate `firmware_cache_ttl` at construction.
+**Verification:** unverified — over cap.
+
+### [LOW] Firmware bin cache re-scans disk on every OTA POST until a valid bin exists
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:66-72`
+**Issue:** The TTL short-circuit requires a non-empty `files_by_model`; with no conforming bins yet that's falsy, so the glob+regex scan runs on every poll and `updated_at` is meaningless.
+**Fix:** Track freshness with a separate `_scanned` flag/timestamp independent of emptiness.
+**Verification:** unverified — over cap.
+
+### [LOW] Admin MCP handlers fire-and-forget send() with no guard for a torn-down socket
+**File:** `custom-providers/xiaozhi-patches/http_server.py:146, 194, 242, 288, 338`
+**Issue:** Between the registry lookup and the spawned send, the WS can close; `send()` on a dead socket raises in the spawned task while the HTTP caller already got `{"ok":true}`.
+**Fix:** Check `conn.websocket` state in a small coroutine and catch+log; or await the send before returning.
+**Verification:** unverified — over cap.
+
+### [LOW] set-toggle/set-state have no response correlation — device-side failures invisible; head-angles unclamped
+**File:** `custom-providers/xiaozhi-patches/http_server.py:143, 191, 239, 285, 335`
+**Issue:** MCP calls use a truncated wall-clock id and never match the device's jsonrpc reply, so a device-side rejection still returns `{"ok":true}`. set-head-angles forwards arbitrary ints (no clamp).
+**Fix:** Clamp head-angle yaw/pitch/speed to firmware-legal ranges; optionally correlate by request id with a timeout, or document best-effort.
+**Verification:** unverified — over cap.
+
+### [LOW] play-asset format inference treats bare .opus as Ogg
+**File:** `custom-providers/xiaozhi-patches/http_server.py:406-411`
+**Issue:** `.opus → format=ogg` fails on raw Opus; unmapped extensions yield `fmt=None` (autodetect) with no distinct log; the songs picker advertises `.opus` so it can silently fail behind an already-sent 200.
+**Fix:** Let ffmpeg autodetect for `.opus`; on decode failure return a distinguishable error rather than a swallowed warning.
+**Verification:** unverified — over cap.
+
+### [LOW] OTA mqtt allowlist token logic undocumented coupling
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:283-295`
+**Issue:** A whitelisted device gets an empty token and relies on the WS-side allowlist bypass; remove it from the whitelist later and it has no token to fall back on.
+**Fix:** Document the coupling, or always issue a token regardless of whitelist membership.
+**Verification:** unverified — over cap.
+
+### [LOW] play-asset resample can feed huge factors to resample_poly; no sample_rate guard
+**File:** `custom-providers/xiaozhi-patches/http_server.py:415-420`
+**Issue:** Coprime rates give large up/down factors (slow/memory-heavy filter); a 0/None `conn.sample_rate` blows up inside `_decode` and is masked by the broad except.
+**Fix:** Validate `conn.sample_rate > 0`; log src/tgt rates on decode failure.
+**Verification:** unverified — over cap.
+
+### [LOW] Admin routes resolve target via next(iter(...)) — nondeterministic device with multiple StackChans
+**File:** `custom-providers/xiaozhi-patches/http_server.py:55, 87, 123, 171, 218, 266, 316, 388, 523`
+**Issue:** With >1 device and no `device_id`, handlers act on an arbitrary dict entry; abort/set-state can hit the wrong robot.
+**Fix:** Require explicit `device_id` (409/400) when multiple devices are connected.
+**Verification:** unverified — over cap.
+
+### [LOW] EventTextMessageHandler attributes events to "unknown" device on header miss
+**File:** `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:60-65`
+**Issue:** A bare try/except leaves `device_id="unknown"` if `conn.headers` is None, so dotty-behaviour accumulates per-device state under a bogus id that never matches the real device — consumers silently never fire.
+**Fix:** Resolve device_id like the WS registration does; drop the event with a warning rather than relay under a fabricated id.
+**Verification:** unverified — over cap.
+
+### [QUALITY/LOW] Massive duplication + ms-truncated ids across the MCP admin handlers
+**File:** `custom-providers/xiaozhi-patches/http_server.py:101-343`
+**Issue:** Five near-identical handlers repeat parse/lookup/envelope/spawn (~250 lines), each using `id = int(time.time()*1000) % 0x7FFFFFFF` which collides within a millisecond.
+**Fix:** Extract a `_mcp_call(...)` helper; use a monotonic counter / uuid-derived id.
+**Verification:** unverified — over cap.
+
+### [INFO] play-asset path containment (bridge-callee view)
+**File:** `custom-providers/xiaozhi-patches/http_server.py:376-384`
+**Issue:** The bridge's own play-song basename-guards, but the xiaozhi callee validates only `os.path.exists`, so the trust boundary is weaker than the bridge layer implies (duplicate of G10, flagged from the bridge scope).
+**Fix:** Resolve realpath under the songs base in play-asset.
+**Verification:** unverified — over cap.
+
+### [INFO] _http_response param name does not match the websockets process_request contract
+**File:** `custom-providers/xiaozhi-patches/websocket_server.py:157-164`
+**Issue:** The param is really a `Request` (accessed as `request_headers.headers`), which misleads readers.
+**Fix:** Rename to `request`, access `request.headers`.
+**Verification:** unverified — over cap.
+
+---
+
+## Bridge dashboard (FastAPI :8081)
+
+### [MEDIUM] Dashboard action endpoints always block 8s and report "no reply" — the event producer is dead
+**File:** `bridge.py:613-626` (consumed at `bridge/dashboard.py:658-704, 2091-2133`)
+**Issue:** `_inject_or_error` subscribes to the bridge event bus and waits 8s for Dotty's reply, but nothing ever enqueues onto `_dashboard_event_listeners` — the producer moved to dotty-pi in #36 and was never re-wired. Every Say/Dance/Mood/Story click blocks the full 8s then renders "Sent — no reply in 8s."; the SSE stream only emits heartbeats.
+**Fix:** Either wire a real producer (dotty-pi/xiaozhi POSTs completed turns to a bridge endpoint that calls `put_nowait`), or drop the subscribe/wait and return "Sent" immediately.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] Blocking synchronous HTTP inside async dashboard routes stalls the event loop
+**File:** `bridge.py:471-504` (`_dotty_behaviour_get`); `bridge/dashboard.py:193-218` (`_fetch_robot_photo`), 1366, 2085, 801, 1925
+**Issue:** The dotty-behaviour getters and `_fetch_robot_photo` do synchronous `requests.get` with no `to_thread`, called from async routes; each uncached call blocks the whole asyncio loop for 1.5-2.0s, freezing all clients. The HTMX 10s poll fans each render into 3-6 such calls. The codebase already uses `to_thread` for device-count/songs, so these are clear omissions. `_build_perception_card_ctx`'s "no I/O" docstring is now false.
+**Fix:** Wrap blocking HTTP in `asyncio.to_thread` (or use `httpx.AsyncClient`); fix the stale docstring.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] CSRF middleware blocks the localhost /admin/* operator endpoints
+**File:** `bridge/csrf.py:33, 69-70, 83`; `bridge.py:800-924`
+**Issue:** CSRFMiddleware is app-wide and exempts only `/api/`, `/metrics`, `/health`. The `/admin/*` router (documented as the localhost CLI back-channel) is not exempt and has no CSRF cookie, so curl/script calls are 403'd before reaching `_admin_require_localhost` — the entire documented admin surface is unusable via its intended caller.
+**Fix:** Add `/admin/` to `_EXEMPT_PREFIXES` (the router already has its own localhost auth).
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] SSE /events served under BaseHTTPMiddleware (CSRF) — Starlette buffering hazard
+**File:** `bridge/dashboard.py:2091-2133`; `bridge/csrf.py:73-98`
+**Issue:** CSRFMiddleware subclasses `BaseHTTPMiddleware`, a documented SSE footgun that buffers chunks and breaks `is_disconnected()`, defeating `X-Accel-Buffering: no`. Today only heartbeats flow, but the channel is structurally degraded once a producer is wired back.
+**Fix:** Exempt the SSE path, or migrate CSRFMiddleware to raw ASGI so streaming responses pass through.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Kid/smart-mode toggles report ok:False while having already persisted+applied the flip
+**File:** `bridge.py:630-643, 695-707`
+**Issue:** `_dashboard_set_kid_mode` persists + applies the state first, then dispatches the firmware toggle; if the device doesn't ack, it returns `{ok:False}` even though the bridge already flipped. The UI shows "toggle failed", the operator re-toggles, and the state ping-pongs out of sync.
+**Fix:** Return `ok:True` with a `device_pushed:false` warning when the bridge write succeeded but the LED push failed (mirror the `/admin/kid-mode` shape).
+**Verification:** unverified — over cap.
+
+### [MEDIUM] network_mode: host binds dashboard + /metrics to 0.0.0.0 with auth unset by default
+**File:** `bridge/docker-compose.yml:31, 41-60`; `bridge.py:936`; `bridge/dashboard.py:259-267`
+**Issue:** The shipped compose sets no dashboard user/pass/CSRF secret; auth is opt-in and returns immediately when either env var is empty; host networking exposes the full mutation surface and `/metrics` to the whole LAN unauthenticated.
+**Fix:** Ship the compose with dashboard user/pass + a persistent CSRF secret from `.env`, and/or bind `127.0.0.1` by default; at minimum document the required auth env.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Async dashboard routes read + JSON-parse the entire daily convo log synchronously
+**File:** `bridge/dashboard.py:377-398, 472-514, 517-555, 1631-1648`
+**Issue:** `_stackchan_last_seen`, `alerts_count`, `alerts_detail` read the whole `convo-*.ndjson` and `json.loads` every line with no `to_thread`, from async routes polled every ~10s per tab; a multi-MB log blocks the loop on each poll.
+**Fix:** Wrap the read+parse in `asyncio.to_thread`; optionally tail rather than parse the whole day.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Dashboard /actions/say and /actions/start-story bypass the kid-mode content filter
+**File:** `bridge/dashboard.py:706-729, 732-773`
+**Issue:** `say()`/`start_story()` sanitise control chars and length but never call `content_filter()` (imported and available), so an operator (or any LAN client when auth is unset) can make Dotty speak arbitrary unfiltered text, and these turns never populate the safety ring.
+**Fix:** Run the sanitised text through `content_filter()` when kid-mode is on; record the hit.
+**Verification:** unverified — over cap.
+
+### [QUALITY/MEDIUM] security_watch.py is entirely dead code; only get_recent_cycles() is reachable
+**File:** `bridge/security_watch.py:1-630`
+**Issue:** Nothing calls `run_security_consumer`, `start_device_timer`, etc.; the perception role moved to dotty-behaviour in #36. ~580 lines run nowhere; `RECENT_CYCLES` is always empty; the docstring still describes firmware tools that "do not exist as of 2026-04-27".
+**Fix:** Delete the module + the `_build_security_panel_ctx` route, or repoint the panel at a dotty-behaviour HTTP getter.
+**Verification:** unverified — over cap.
+
+### [LOW] host/footer 'disk' vitals read the container overlay fs, not the host disk
+**File:** `bridge/dashboard.py:1614-1620, 1734-1739, 1793-1796`
+**Issue:** `shutil.disk_usage('/')` inside the container reports the overlay fs, not the Unraid appdata volume, so the disk gauge is misleading (mem/cpu are host-wide via the shared kernel).
+**Fix:** Point at a bind-mounted host path, or relabel as "container disk".
+**Verification:** unverified — over cap.
+
+### [LOW] say/start-story length cap enforced before whitespace collapse
+**File:** `bridge/dashboard.py:714-723, 746-753`
+**Issue:** The `len > 500` check runs before whitespace collapse, so a pasted message with long whitespace runs but short visible content is wrongly rejected.
+**Fix:** Sanitise/collapse first, then length-check the cleaned text.
+**Verification:** unverified — over cap.
+
+### [LOW] play-asset / vision-photo proxy interpolate unencoded device_id into an internal URL
+**File:** `bridge/dashboard.py:201, 638, 1924`
+**Issue:** `_fetch_robot_photo` builds the behaviour URL with the raw `device_id` path-param (unvalidated, unencoded), allowing query/fragment injection into the internal request.
+**Fix:** `urllib.parse.quote(device_id, safe='')` and validate against an id charset, returning 400 on mismatch.
+**Verification:** unverified — over cap.
+
+### [LOW] _dotty_behaviour_get caches the failure fallback for the full TTL
+**File:** `bridge.py:492-504`
+**Issue:** On any error it writes the empty fallback into the cache for the TTL, so every tile blanks for ~2s after each blip even after recovery.
+**Fix:** Cache only on success; return `fallback` on the error path without caching.
+**Verification:** unverified — over cap.
+
+### [LOW] bridge writes to brain.db (RW) primarily owned by dotty-pi — approve/redact can lock/race
+**File:** `bridge.py:316, 349`
+**Issue:** `_voice_memory_approve/_delete_blocking` open brain.db RW across containers; in non-WAL delete mode a writer blocks readers, and failures are swallowed and surface as a generic "not found".
+**Fix:** Set `PRAGMA busy_timeout`, surface lock failures distinctly; longer term route approve/redact through dotty-pi (the canonical writer).
+**Verification:** unverified — over cap.
+
+### [LOW] host_detail 'server' modal hardcodes 'Recent errors today: —' despite the count being computed elsewhere
+**File:** `bridge/dashboard.py:1832`
+**Issue:** `alerts_count()` already tallies today's errored turns from the convo log; the modal shows a permanent dash.
+**Fix:** Factor the tally into a helper and reuse it.
+**Verification:** unverified — over cap.
+
+### [LOW] security_watch defaults use retired RPi/zeroclaw paths and wrong port
+**File:** `bridge/security_watch.py:85-101`
+**Issue:** `SECURITY_LOG_DIR` defaults `CONVO_LOG_DIR` to `/root/zeroclaw-bridge/logs` (disagreeing with dashboard.py's default) and `_BRIDGE_INTERNAL_URL` defaults to port 8080 while the bridge listens on 8081.
+**Fix:** Align the default with dashboard.py; fix the port to 8081 — or delete the dead module.
+**Verification:** confirmed 2/3 lenses.
+
+### [LOW] Voice-tools inventory shows 5 tools but dotty-pi-ext ships 7
+**File:** `bridge/dashboard.py:965-981`
+**Issue:** `_VOICE_TOOLS` hardcodes 5 and the docstring says "same five values"; recall_person/remember_person (added in #53) are missing.
+**Fix:** Add the two person-memory tools; source from a shared manifest.
+**Verification:** unverified — over cap.
+
+### [LOW] Host-detail 'bridge' modal hardcodes Device: Raspberry Pi
+**File:** `bridge/dashboard.py:1773`
+**Issue:** The bridge now runs as the `dotty-bridge` Docker container on Unraid; the modal reports stale hardware provenance.
+**Fix:** Relabel as "Docker container (Unraid host)" or drop the row.
+**Verification:** unverified — over cap.
+
+### [LOW] CSRF warning + /admin/safety self-rewrite reference retired zeroclaw paths
+**File:** `bridge/csrf.py:43`; `bridge.py:872-921`
+**Issue:** The CSRF warning points operators at `/etc/default/zeroclaw-bridge` (no effect in a container; CSRF cookies invalidate on every restart). `_admin_safety` self-edits bridge.py on disk — changes nothing live (the consumer was in ZeroClaw) and is wiped on the next image rebuild.
+**Fix:** Update the CSRF message to the container env mechanism; remove the `/admin/safety` self-rewrite or move the allowlist to a mounted state file.
+**Verification:** unverified — over cap (both).
+
+### [QUALITY/LOW–INFO] Dead/retired metrics + Tier1Slim narrative
+**File:** `bridge/metrics.py:100-160` (128 = `dotty_active_acp_sessions`); `bridge/dashboard.py:847-872, 1113-1126, 1438-1480`
+**Issue:** Only `dotty_kid_mode_active` and `dotty_content_filter_hits_total` are ever observed; the rest (incl. the ACP gauge) always export 0. The logger name is `zeroclaw-bridge.metrics`. Smart-mode code carries large dead Tier1Slim/zeroclaw commentary for a card that does nothing.
+**Fix:** Remove unproduced metrics (esp. the ACP gauge), rename the logger, collapse the smart-mode card to its real behaviour.
+**Verification:** unverified — over cap.
+
+### [INFO] Dashboard live perception feed (EventSource '/api/perception/feed') 404s — endpoint ripped in #111, consumer left behind
+**File:** `bridge/templates/dashboard.html:564`
+**Issue:** The page (served from :8081) opens `EventSource('/api/perception/feed')`, but the bridge serves no `/api/*` routes — commit c6df5c5 (#111) deleted the endpoint and left the EventSource. The live feed never streams, every dotty-refresh nudge is dead, and the browser hammers a 404 reconnect every few seconds per open tab. The real SSE lives on dotty-behaviour:8090 (different origin).
+**Fix:** Add a bridge SSE passthrough under `/api/`, or point the EventSource at the dotty-behaviour origin with CORS configured.
+**Verification:** confirmed 2/3 lenses.
+
+---
+
+## Voice LLM providers (PiVoiceLLM, OpenAICompat)
+
+### [MEDIUM] Turn timeout is a fixed wall-clock deadline that ignores streaming progress
+**File:** `custom-providers/pi_voice/pi_client.py:220-269`
+**Issue:** `deadline` is set once (default 120s) and never extended while text streams. A healthy long reply (think_hard escalation, 6-sentence story) is killed mid-stream and the user hears the "(brain offline)" fallback. The timeout should bound silence, not total length.
+**Fix:** Reset `deadline` on each `text_delta` so the cap only fires when pi goes quiet.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] new_session failure proceeds with un-reset pi session, leaking prior-turn context
+**File:** `custom-providers/pi_voice/pi_voice.py:136-141`
+**Issue:** On `PiClientError` from `new_session()`, the code logs and continues and sets `_first_turn = False` unconditionally, so the next turn runs against pi's non-reset session — carrying prior content (or a partially-absorbed jailbreak) into the next, possibly child, interaction.
+**Fix:** Force a hard reset (close + respawn) on `new_session` failure, or surface the failure rather than treating a failed reset as a fresh turn.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] _closed flag never reset after close() + reuse, suppressing reader-thread crash logging
+**File:** `custom-providers/pi_voice/pi_client.py:171-182, 311-313, 352-354`
+**Issue:** `close()` sets `_closed=True`; `_ensure_started()` respawns without clearing it, so the reader threads' `if not self._closed:` guards swallow genuine crashes — turns time out with no diagnostic.
+**Fix:** Reset `_closed=False` on respawn; scope the suppression to the process generation.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Abandoned iter_turn_text leaves pi streaming; a stale agent_end can terminate the next turn
+**File:** `custom-providers/pi_voice/pi_client.py:211-269` (also 188-209)
+**Issue:** On barge-in/TTS-abort the generator is GC'd without consuming `agent_end`; pi keeps generating and queues frames. `agent_end` is not id-matched, so an abandoned turn's trailing `agent_end` can terminate the NEXT `iter_turn_text`, truncating the next reply to empty/partial.
+**Fix:** Send an explicit cancel to pi on abandon (try/finally), drain prior frames by req_id, and id-match `agent_end`.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] OpenAICompat can emit two emojis when a valid emoji is not at the start
+**File:** `custom-providers/openai_compat/openai_compat.py:218-229`
+**Issue:** Enforcement only checks `so_far.startswith(emoji)`. For "Well, 😊 hi there" the check fails, so it prepends `😐` AND yields content still containing `😊` — two emojis, violating the single-emoji HARD CONSTRAINT; firmware face keys on the first, the second garbles TTS.
+**Fix:** Strip embedded emojis from the body before yielding, or buffer until the first non-whitespace char and filter subsequent emojis.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] OpenAICompat speaks chain-of-thought when pointed at a reasoning model
+**File:** `custom-providers/openai_compat/openai_compat.py:189-229`
+**Issue:** Unlike PiClient, OpenAICompat has no thinking filter — it yields `delta.content` verbatim. Inline `<think>...</think>` is spoken aloud and the leading `<` defeats the emoji check; separate `reasoning_content` is dropped but the silent gap can trip the turn timeout.
+**Fix:** Strip `<think>...</think>` (stateful across chunks), ignore `reasoning_content`, or send a param to disable thinking.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] OpenAICompat appends the safety/format suffix to the wrong message when no user turn exists
+**File:** `custom-providers/openai_compat/openai_compat.py:101-114`
+**Issue:** `_TURN_SUFFIX` is appended only at `last_user_idx`; if the final turn is system/assistant/tool (greeter injections), `last_user_idx` is None and the suffix — carrying emoji rule + kid-mode filter — is never injected, so the model runs unconstrained for that turn.
+**Fix:** When `last_user_idx` is None, append the suffix to a synthesized trailing user message or the last message regardless of role.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] OpenAICompat yields whitespace-only content chunks to TTS before emoji enforcement
+**File:** `custom-providers/openai_compat/openai_compat.py:216-229`
+**Issue:** Whitespace-only deltas are yielded before `so_far` is non-empty and the emoji check runs; the first thing TTS/firmware sees is whitespace, not the emoji the contract promises. If the stream is all whitespace, the fallback fires after whitespace already went out.
+**Fix:** Buffer until `so_far` is non-empty before yielding anything.
+**Verification:** unverified — over cap (duplicate-class with F139).
+
+### [LOW] Documented extra_pi_flags config key is silently ignored
+**File:** `custom-providers/pi_voice/pi_voice.py:29-30, 107-117`
+**Issue:** The docstring documents `extra_pi_flags`, but `__init__` reads only `container_name`; `make_default_pi_client()` consults only the `DOTTY_PI_EXTRA_FLAGS` env var. A user setting `extra_pi_flags` in `.config.yaml` gets no effect.
+**Fix:** Read `config.get('extra_pi_flags')` and thread it in, or remove it from the docstring and document the env var as the only mechanism.
+**Verification:** confirmed 2/3 lenses.
+
+### [LOW] make_default_pi_client ignores the resolved container_name
+**File:** `custom-providers/pi_voice/pi_voice.py:107-117`
+**Issue:** The provider resolves and logs `container_name`, but `make_default_pi_client()` re-reads `DOTTY_PI_CONTAINER` itself and ignores it — the configured container name is logged but inert in production.
+**Fix:** Pass `self._container` into `make_default_pi_client`.
+**Verification:** unverified — over cap.
+
+### [LOW] PiVoiceLLM fallback strings violate the mandatory emoji-prefix protocol
+**File:** `custom-providers/pi_voice/pi_voice.py:130, 150`
+**Issue:** `yield "(empty turn)"` and `yield "(brain offline ...)"` begin with `(`; the firmware emotion parser sees `(` and produces no/garbage face. OpenAICompat correctly prefixes its fallbacks.
+**Fix:** Prepend an allowed emoji (e.g. `😐`) to both fallbacks.
+**Verification:** confirmed 2/3 lenses.
+
+### [LOW] new_session response match does not verify request id
+**File:** `custom-providers/pi_voice/pi_client.py:192-209`
+**Issue:** The drain loop matches only `type==response, command==new_session`, not `id==req_id`; a stale `new_session` response can be accepted early.
+**Fix:** Add `and frame.get('id') == req_id`.
+**Verification:** unverified — over cap.
+
+### [LOW] PiVoiceLLM _first_turn desyncs from the pi process after a respawn
+**File:** `custom-providers/pi_voice/pi_voice.py:136-141`
+**Issue:** If pi dies after turn 1, turn 2 runs `new_session()` against a freshly respawned process that has no session — a spurious 10s `new_session timed out` is swallowed, adding dead air.
+**Fix:** Have PiClient signal a fresh spawn so the first-turn-after-respawn skips `new_session()`.
+**Verification:** unverified — over cap.
+
+### [LOW] iter_turn_text process-exit detection only runs on queue-empty
+**File:** `custom-providers/pi_voice/pi_client.py:222-269`
+**Issue:** A crash with frames still queued never hits the Empty branch, so it spins to the 120s turn timeout and reports "turn timed out" instead of "pi process exited", delaying the fallback by up to 2 minutes.
+**Fix:** Check `self._proc.poll()` on every iteration.
+**Verification:** unverified — over cap.
+
+### [LOW] _next_id increments shared counter without the lock; reader-thread frame routing races a respawn
+**File:** `custom-providers/pi_voice/pi_client.py:283-285, 149-169`
+**Issue:** A respawn swaps `_event_queue` under lock while the old daemon reader (never joined) can still `put` stale frames into the new queue, injecting a previous process's frames into the new turn.
+**Fix:** Join/stop prior reader threads before swapping the queue; bind each reader to its specific queue/proc; lock the id mutation.
+**Verification:** unverified — over cap.
+
+### [LOW] _completions_url mishandles a base ending in /chat/completions
+**File:** `custom-providers/openai_compat/openai_compat.py:125-132`
+**Issue:** The endsWith heuristic can double the path (e.g. a gateway route `/chat/completions/stream`).
+**Fix:** Make the endpoint construction explicit via a config flag, or document url must be the base.
+**Verification:** unverified — over cap.
+
+### [LOW] OpenAICompat yields leading whitespace before emoji-prefix engages
+**File:** `custom-providers/openai_compat/openai_compat.py:218-229`
+**Issue:** A whitespace-only first chunk is yielded before enforcement, so the first TTS chunk isn't the emoji.
+**Fix:** Buffer until `so_far` is non-empty; strip leading whitespace.
+**Verification:** unverified — over cap.
+
+### [QUALITY/LOW–INFO] Dead/unreachable helpers + unsynchronized stderr ring
+**File:** `custom-providers/openai_compat/openai_compat.py:134-140` (`_chunk_sentences`); `custom-providers/pi_voice/pi_client.py:63-81` (`default_subprocess_factory`), 275-277/343-354 (stderr ring)
+**Issue:** `_chunk_sentences` + its `_SENTENCE_BOUNDARY` import are dead; the ssh `default_subprocess_factory` is unreachable in production; the stderr ring is mutated/snapshotted across threads without the lock the rest of the class uses.
+**Fix:** Remove dead code or wire it; use a `deque(maxlen=...)` and/or guard with `self._lock`.
+**Verification:** unverified — over cap.
+
+---
+
+## ASR/TTS providers (FunASR, Whisper, EdgeStream, Piper)
+
+### [HIGH] Mid-utterance synth failure emits SentenceType.LAST, truncating the rest of the reply
+**File:** `custom-providers/edge_stream/edge_stream.py:139-143` (mirror: `piper_local.py:187-191`)
+**Issue:** The except handler unconditionally pushes `(SentenceType.LAST, [], None)` regardless of `is_last`. A multi-segment reply where an early segment's synth throws tells xiaozhi/firmware the whole response is finished, so every remaining segment is dropped and the device stops mid-sentence.
+**Fix:** Only emit LAST from the failure path when `is_last` is True; otherwise log and continue.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] processed_chars over-count in edge_stream and piper_local
+**File:** `custom-providers/edge_stream/edge_stream.py:67-74`; `custom-providers/piper_local/piper_local.py:114-121`
+**Issue:** `remaining_text = full_text[self.processed_chars:]` (absolute index) then `self.processed_chars += len(full_text)` over-counts; post-condition should be `== len(full_text)`. Masked today by the FIRST reset, but a re-entered LAST drops the final sentence's audio.
+**Fix:** `self.processed_chars = len(full_text)` (or `+= len(remaining_text)`) in both; consider a shared mixin.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] fun_local crashes in __init__ when output_dir is unset
+**File:** `custom-providers/asr/fun_local.py:51-58`
+**Issue:** `os.makedirs(None)` raises TypeError when `output_dir` is absent; whisper_local guards this, fun_local does not, so the two ASR providers are inconsistent.
+**Fix:** `if self.output_dir: os.makedirs(self.output_dir, exist_ok=True)`.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] ASR model invoked from worker threads with no lock — not thread-safe under concurrent transcription
+**File:** `custom-providers/asr/whisper_local.py:107-109, 161-173` (mirror: `fun_local.py:81-88`)
+**Issue:** The singleton model is called via `asyncio.to_thread` from separate threads for overlapping sessions; faster-whisper/FunASR aren't safe for concurrent calls on the same model, risking corrupted output or a segfault.
+**Fix:** Serialize inference with a per-instance `threading.Lock` inside the blocking call.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] before_stop play files dropped when the final segment's synthesis fails
+**File:** `custom-providers/edge_stream/edge_stream.py:139-143` (mirror piper 187-191)
+**Issue:** The except handler never calls `_process_before_stop_play_files()`, so a LAST-segment synth failure abandons queued trailing assets (and can leak them into the next utterance).
+**Fix:** On the except path, when `is_last`, still process+clear the before_stop play files.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] SentenceType.FIRST emitted once per segment instead of once per reply
+**File:** `custom-providers/edge_stream/edge_stream.py:101` (mirror `piper_local.py:146`)
+**Issue:** `text_to_speak` puts FIRST at the top of every call; a multi-segment reply pushes multiple FIRSTs, which downstream treats as start-of-response and can re-trigger talk animation mid-sentence.
+**Fix:** Track a per-reply first-segment flag; emit FIRST only for the first segment.
+**Verification:** unverified — over cap.
+
+### [LOW] Whisper odd-length PCM buffer raises ValueError instead of degrading
+**File:** `custom-providers/asr/whisper_local.py:104`
+**Issue:** `np.frombuffer(..., int16)` raises on an odd byte count (truncated final frame); caught by the broad except → empty transcript with no retry.
+**Fix:** Trim to an even length before `frombuffer`.
+**Verification:** unverified — over cap.
+
+### [LOW] get_emotion matches the first mapped emoji anywhere, not the required leading emoji; default 🙂 outside the set
+**File:** `custom-providers/textUtils.py:146-152`
+**Issue:** The protocol requires the FIRST char to be the emotion emoji, but `get_emotion` breaks on the first mapped emoji anywhere, selecting a wrong/secondary face; the default `🙂` is outside `ALLOWED_EMOJIS`/the firmware set.
+**Fix:** Resolve emotion from the leading grapheme only; default to `😐` (the in-set neutral).
+**Verification:** unverified — over cap.
+
+### [LOW] piper effective_rate==24000 shortcut skips resampling when native rate isn't 24000
+**File:** `custom-providers/piper_local/piper_local.py:67-74`
+**Issue:** The no-resample shortcut conflates "no pitch shift" with "no rate conversion"; a 22050 Hz voice with a pitch_scale that lands on 24000 emits raw native-rate PCM into a 24000 Hz encoder, corrupting playback speed/pitch.
+**Fix:** Gate the shortcut on `src_rate == 24000 AND pitch_scale == 1.0`; otherwise always go through the gcd/resample branch.
+**Verification:** unverified — over cap.
+
+### [LOW] piper length_scale not validated for <= 0 (unlike pitch_scale)
+**File:** `custom-providers/piper_local/piper_local.py:32-42`
+**Issue:** `pitch_scale` raises on `<= 0` but `length_scale` (Piper's speed knob) is unchecked; a 0/negative value yields empty/garbage audio with no early error.
+**Fix:** Mirror the pitch_scale guard for length_scale.
+**Verification:** unverified — over cap.
+
+### [LOW] whisper metrics: lang_prob can be None with forced language, raising in the f-string
+**File:** `custom-providers/asr/whisper_local.py:132-137`
+**Issue:** With a forced language, `language_probability` can be present-but-None; the `getattr(..., 0.0)` default doesn't fire and `{lang_prob:.3f}` raises, swallowed by the except — so the #105 ASR-METRICS line is silently dropped on every such utterance.
+**Fix:** `lang_prob = getattr(...) or 0.0`.
+**Verification:** unverified — over cap.
+
+### [LOW] FIRST audio-start marker emitted even when synth yields zero audio
+**File:** `custom-providers/edge_stream/edge_stream.py:101-115` (mirror piper 146-159)
+**Issue:** A mid-reply empty-synth segment emits FIRST then returns with no frames and no LAST, wedging per-sentence marker accounting.
+**Fix:** Emit FIRST only after confirming there is audio, or enqueue a terminating marker on the empty-synth early return.
+**Verification:** unverified — over cap.
+
+### [QUALITY/LOW–INFO] delete_audio_file unused; end_of_stream always True on non-last segments
+**File:** `custom-providers/asr/fun_local.py:55` (and `whisper_local.py:46`); `custom-providers/edge_stream/edge_stream.py:121-137` (mirror piper 176-182)
+**Issue:** `delete_audio_file` is stored but never honored (utterance WAVs accumulate); the trailing partial frame is flushed with `end_of_stream=True` on every segment, not just the last.
+**Fix:** Honor or remove `delete_audio_file`; pass `end_of_stream=is_last`.
+**Verification:** unverified — over cap.
+
+---
+
+## dotty-behaviour core (app, routes, perception, dispatch, config)
+
+### [HIGH] room_view roster recognition silently fails when person id != display_name
+**File:** `dotty-behaviour/vision/room_view.py:115-124, 159-167`
+**Issue:** `name_choices` is built from `p.display_name`, but `parse_room_view_response` validates against `roster_ids` (which are `p.id` from `roster_ids_with_appearance()`). Whenever `id != display_name.lower()` (the common case), a correct VLM identification falls through to None, the synthetic `face_recognized` never fires, and named greetings regress to bare/no greeting. Masked because the test fake reimplements the helper as `display_name.lower()` with id==display_name fixtures.
+**Fix:** Make the prompt vocabulary and the validation set use the same key (build `name_choices` from `p.id`, or resolve the returned display-name back to the id). Fix the test fake to return `p.id` and add an id != display_name fixture.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] Consumer task crashes are silently swallowed (no log, no restart)
+**File:** `dotty-behaviour/main.py:325-341`
+**Issue:** Consumers are launched with `create_task` and only awaited at shutdown via `gather(..., return_exceptions=True)`; a runtime exception is captured and discarded at shutdown, never logged when it happens, and the consumer is never restarted while the daemon still reports "ready".
+**Fix:** Attach a done-callback that logs non-cancelled exceptions; optionally supervise/restart each consumer.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] No upload size limit on /api/vision/explain and /api/audio/explain (LAN OOM)
+**File:** `dotty-behaviour/routes/vision.py:145` (and `audio.py:87`)
+**Issue:** `await file.read()` reads the entire multipart upload into memory then base64-encodes (~1.33x) with no Content-Length cap; both endpoints bind `0.0.0.0:8090`. A single large/malicious POST can exhaust container memory and take down the daemon (and all consumers). The JPEG is also retained per-device in `vision_cache`.
+**Fix:** Enforce a max upload size (e.g. 5 MB JPEG / 10 MB audio) up front and reject >N with 413.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] vision_latest lost-wakeup race produces spurious 404s
+**File:** `dotty-behaviour/routes/vision.py:331-352`
+**Issue:** `vision_latest` pops the cache, registers a waiter, then awaits the Event. If `explain`'s `signal_vision_waiters()` fires between pop and registration, the signal is lost (signal only set()s already-registered Events), so the waiter blocks to the 15s timeout and 404s even though a valid description exists.
+**Fix:** Make the wakeup level-triggered: re-check the cache after registering before awaiting, or use a generation counter. Same for the audio waiter.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] vision_latest unconditionally evicts a fresh capture (and its JPEG) written by another producer
+**File:** `dotty-behaviour/routes/vision.py:332`
+**Issue:** The unconditional `pop` deletes whatever is cached, including a fresh entry another producer wrote microseconds earlier (idle_photographer / room_view), discarding its `jpeg_bytes` that `/api/vision/photo` serves; a subsequent photo GET 404s.
+**Fix:** Pop only entries older than the TTL; or snapshot a request-start time and accept any entry newer than it.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] Failed room_view VLM call still arms the 120s cooldown
+**File:** `dotty-behaviour/routes/vision.py:188-204`
+**Issue:** `last_room_view_capture_t` is set before the VLM call, which never raises (returns sentinels on failure), so a transient VLM blip arms the full 120s cooldown despite no usable description — repeated blips disable named greetings for minutes.
+**Fix:** Arm the cooldown only after a successful, non-sentinel response, or use a short failure-cooldown.
+**Verification:** unverified — over cap.
+
+### [LOW] /api/perception/state emits invalid JSON (Infinity) for devices with no last_event_t
+**File:** `dotty-behaviour/perception/state.py:328-336`
+**Issue:** `_annotate` sets `age = float('inf')` → serialized as bare `Infinity` (not valid JSON), breaking strict parsers/the dashboard card. Reachable for a known device that got a room_view capture but never sent a perception event, and unconditionally for any unknown `device_id`.
+**Fix:** Use a JSON-safe value (None / -1) for missing `last_event_t`; add a regression test asserting the body parses as standard JSON.
+**Verification:** unverified — over cap.
+
+### [LOW] Failed/empty weather fetch arms the full 30-min TTL
+**File:** `dotty-behaviour/calendar_/cache.py:124-127` (driven by `poll.py:46-48`)
+**Issue:** `set_weather` updates `weather_text` only on truthy text but always bumps `weather_fetched_perf`, so a transient weather failure marks the cache fresh for 30 minutes and serves stale (or empty) text. Same class as the room_view cooldown bug, distinct site (reported twice as F206/F246).
+**Fix:** Advance `weather_fetched_perf` only on a non-empty fetch; add a test.
+**Verification:** unverified — over cap.
+
+### [LOW] perception/state limit query params unvalidated (negative/zero slice quirks)
+**File:** `dotty-behaviour/routes/perception.py:88-99, 124`
+**Issue:** `limit` flows into `items[:limit]` / `balances[-limit:]` unbounded; `limit=-3` drops the 3 newest, `limit=0` returns `[]` for one path and the FULL list for `balances[-0:]`.
+**Fix:** Clamp `limit = max(0, min(limit, MAX))`; special-case `limit <= 0` for the balance series.
+**Verification:** unverified — over cap.
+
+### [LOW] Client-supplied event ts can be set in the future, defeating staleness gates
+**File:** `dotty-behaviour/routes/perception.py:61-68`
+**Issue:** `payload.ts` is used verbatim; a future ts makes `now - last_t` negative → clamped to 0, so `get_fresh_face_id` treats a stale identity as permanently fresh. ESP32 RTCs are frequently unsynced.
+**Fix:** Reject/clamp implausible future timestamps on ingest; guard `get_fresh_face_id` against negative age.
+**Verification:** unverified — over cap.
+
+### [LOW] VLM error/offline SENTINEL strings cached as a real description and leaked into the perception snapshot
+**File:** `dotty-behaviour/routes/vision.py:195-242`
+**Issue:** `vision_explain` stores the `VLM_OFFLINE_SENTINEL`/`VLM_NETWORK_ERROR_SENTINEL` verbatim with a fresh `wall_ts`; the snapshot then surfaces `You see: ERROR: the vision service didn't respond...` into Dotty's voice prompt for up to 60s, and the idle photographer can persist it to NDJSON.
+**Fix:** Detect the sentinels after `describe_image` and skip the cache write + `signal_vision_waiters`. Same for the audio fallback.
+**Verification:** unverified — over cap.
+
+### [LOW] snapshot.py age-gate constants hardcoded, ignoring env-configurable counterparts
+**File:** `dotty-behaviour/perception/snapshot.py:18-20`
+**Issue:** `VISION_AGE_GATE_SEC` etc. are literals, while config defines the env-overridable TTLs; raising `VISION_CACHE_TTL_SEC` keeps entries longer but the snapshot still gates at 60s. `config.SCENE_SYNTHESIS_AGE_GATE_SEC` has zero readers.
+**Fix:** Import the gates from config (or pass them in); remove the unused config var or document the gates are fixed.
+**Verification:** unverified — over cap.
+
+### [LOW] perception/state stale dance_active never cleared on a missed terminal event
+**File:** `dotty-behaviour/perception/state.py:185-199`
+**Issue:** `dance_active` has no time-based expiry; a dropped `dance_ended`/`state_changed` latches it True indefinitely, permanently suppressing room_view captures and greetings for that device.
+**Fix:** Make `is_dance_active` freshness-bounded against `last_dance_started_t` with a max-dance TTL.
+**Verification:** unverified — over cap.
+
+### [LOW] SSE feed only re-checks client disconnect every 15s, leaking a subscriber queue
+**File:** `dotty-behaviour/routes/perception.py:142-153`
+**Issue:** `is_disconnected()` is checked once per loop before a 15s `wait_for`, so a disconnect mid-block isn't noticed for up to 15s; the queue stays registered and `broadcast()` keeps filling/dropping it.
+**Fix:** Reduce the poll timeout or race the disconnect check against the queue get.
+**Verification:** unverified — over cap.
+
+### [QUALITY/LOW–INFO] Dead prometheus dep; per-request weather subprocess; misplaced imports; None-guard inconsistency
+**File:** `dotty-behaviour/requirements.txt:12-14`; `routes/calendar.py:51-62`; `main.py:40`; `consumers/sleep_dreamer.py:167` & `dance_reflector.py:90`
+**Issue:** `prometheus-client` is pinned but no `/metrics` or counters exist; `/api/calendar/today` spawns a `curl wttr.in` subprocess on the request path even with no calendars configured; `import re`/`import asyncio` are misplaced; two consumers dereference `event.data` directly while siblings use `(event.data or {})`.
+**Fix:** Implement or drop the metrics dep; gate weather refresh on `CALENDAR_IDS`; tidy imports; normalize `event.data` (default_factory or guard uniformly).
+**Verification:** unverified — over cap.
+
+---
+
+## dotty-behaviour consumers/greeter/household/calendar/vision
+
+### [HIGH] Double greeting on every face_recognized — FaceGreeter and ProactiveGreeter both fire
+**File:** `dotty-behaviour/consumers/face_greeter.py:133-186`
+**Issue:** FaceGreeter's named greet ("Oh, it's {name}!") and ProactiveGreeter's LLM greeting both subscribe to `face_recognized`, keep separate cooldown state, and don't coordinate — one recognition produces two back-to-back utterances. The bare path was deliberately suppressed when the roster is identifiable; the named path was not given the same deference.
+**Fix:** Pick one owner (disable FaceGreeter's named path when the proactive greeter is enabled, or share a per-identity cooldown).
+**Verification:** confirmed 2/3 lenses.
+
+### [HIGH] room_view name parser cannot match multi-word display names
+**File:** `dotty-behaviour/vision/room_view.py:72-81, 115-124`
+**Issue:** `name_choices` injects `display_name`, but the NAME regex is a single whitespace-free token; a reply `NAME: Mary Anne` fails the anchored regex entirely, so any member with a space in their display name is a 100% silent identification failure even on a perfect VLM response.
+**Fix:** Allow internal spaces in the NAME group (and normalise), or request a single-token id and map ids→display names. Add a two-word display_name test.
+**Verification:** confirmed 3/3 lenses.
+
+### [HIGH] room_view roster recognition fails when person id != display_name (greeter path)
+**File:** `dotty-behaviour/vision/room_view.py:115-124, 159-167`
+**Issue:** Same id/display_name name-space mismatch as the core finding; `room_match_person_id` is the VLM's display-name token lowercased, then passed as `identity` to `household.get()` which is keyed by id and also misses. (Reported as both F38 and F201.)
+**Fix:** Agree on a single key (prefer `p.id`); fix the test fake and add an id != display_name fixture.
+**Verification:** confirmed 3/3 lenses.
+
+### [HIGH] Greeter calendar lookup never matches an identified person (case mismatch)
+**File:** `dotty-behaviour/greeter/greeter.py:257-259` → `calendar_/cache.py:69-73`
+**Issue:** `identity` is a lowercased person id, but the calendar `person` is set from the title prefix with no case folding (`[Hudson] → "Hudson"`), so `"Hudson" != "hudson"` drops that person's own events from their greeting. Household-bucket events mask the bug.
+**Fix:** Normalise both sides to a common case (lower-case the parsed calendar `person`, or compare case-insensitively); prefer mapping the prefix to the canonical id at fetch time.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] FaceGreeter consumes the greet cooldown even when suppressed by an active dance
+**File:** `dotty-behaviour/consumers/face_greeter.py:148-168, 105-126`
+**Issue:** The cooldown slot is written before the dance-active gate, so every face event during a dance silently burns the cooldown without greeting; the user walks in during a dance, is never greeted, and stays un-greeted for the full cooldown after. `last_face_greet_t` also arms the aborter. (Reported as F160/F207.)
+**Fix:** Move the dance-active (and empty-text) checks above the cooldown write in both handlers.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] last_chat_t is never written on real conversations — QUIET_AFTER_CHAT gates are dead
+**File:** `dotty-behaviour/consumers/face_greeter.py:149-156` + `sound_turner.py:77-79` + `perception/state.py:200-203`
+**Issue:** Named-greet and sound-turner suppress themselves for `*_quiet_after_chat_sec` after the last chat by reading `last_chat_t`, but the only writer is `purr_player.py`; nothing records actual conversation activity, so the gate never fires and Dotty name-greets/head-turns over a live conversation. Regression from bridge.py's `/api/message` ingress.
+**Fix:** Write `last_chat_t` on conversation activity (set it on `chat_status` listening, or POST a conversation event), or drop the gates as inert.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] Greeter day-GC discards every other day's slots; midnight-roll cooldown corruption
+**File:** `dotty-behaviour/greeter/greeter.py:224-228`
+**Issue:** `_take_slot` derives `today` from wall-now but uses `event_ts` for the cooldown; the GC collapses `_state` to `{today: ...}`, wiping (and persisting away) other days. A pre-midnight event handled just after midnight is filed under the new day with old-day cooldown math, letting a near-instant second greeting slip through.
+**Fix:** Key the day on `event_ts`; GC by a retention window (keep today + yesterday).
+**Verification:** unverified — over cap.
+
+### [MEDIUM] SecurityCycle keeps capturing on a missed/early transition
+**File:** `dotty-behaviour/consumers/security_cycle.py:238-257`
+**Issue:** Capture starts/stops purely off live `state_changed`; if the device is already in `security` when the consumer subscribes the timer never starts, and if the non-security transition frame is dropped the per-device capture loop fires the camera forever.
+**Fix:** Seed timers from current `current_state` on subscribe; reconcile each running timer against the live state per cycle.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] calendar fetch time window excludes the final minute of the day
+**File:** `dotty-behaviour/calendar_/fetch.py:60-66`
+**Issue:** `time_max = 23:59:59` with an exclusive `timeMax` loses the last minute; the correct upper bound is the start of the next local day.
+**Fix:** `time_max = (start_of_today + timedelta(days=1)).isoformat()`.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] CalendarCache.flush_for_new_day produces a long empty-context window on day-roll fetch failure
+**File:** `dotty-behaviour/calendar_/cache.py:116-122` + `poll.py:53-75`
+**Issue:** The day-roll eagerly flushes events, and a failing refresh only bumps `calendar_failures`; with backoff the loop may sleep up to 600s showing an EMPTY calendar in the morning even though yesterday's data was serviceable a moment earlier.
+**Fix:** Flush only on a successful fetch, or reset failures / use the base interval for the first retry after a day-roll flush.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] room_view 'no one in view' sentinel uses substring match
+**File:** `dotty-behaviour/vision/room_view.py:152-153`
+**Issue:** `if ROOM_VIEW_NO_PERSON in cleaned.lower()` discards a valid identification whose DESC merely mentions the phrase, throwing away both the description and the matched identity.
+**Fix:** Match the sentinel only when it's the entire reply; try the DESC/NAME regex first.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] FaceIdentifiedRefresher keeps the green ID LED lit when identity came from room_view
+**File:** `dotty-behaviour/consumers/face_identified_refresher.py:65-71`
+**Issue:** The skip gate only suppresses refresh when the face was both absent AND previously lost; a room_view identity sets `last_face_id` without `face_present` or a `face_lost`, so the LED stays green for the full TTL even after the person walked off.
+**Fix:** Treat "identity present but face_present False and never positively detected" as a stop condition.
+**Verification:** unverified — over cap.
+
+### [LOW] FaceLostAborter leaks completed abort tasks in _pending forever
+**File:** `dotty-behaviour/consumers/face_lost_aborter.py:101-103, 47-55`
+**Issue:** A completed abort task with no subsequent face event stays in `_pending`; the dict never shrinks for departed devices.
+**Fix:** Add a done-callback that discards the entry.
+**Verification:** unverified — over cap.
+
+### [LOW] Vision room_view block-reason early return skips stale-cache eviction
+**File:** `dotty-behaviour/routes/vision.py:176-186`
+**Issue:** A gated room_view request writes a fresh cache entry and returns before the stale-eviction loop, so on frequently-gated deployments stale entries for other devices are never reclaimed.
+**Fix:** Run eviction on every exit path, including the block-reason early return.
+**Verification:** unverified — over cap.
+
+### [LOW] Blocking file I/O on the event loop in greeter state persistence
+**File:** `dotty-behaviour/greeter/greeter.py:246, 420-435`
+**Issue:** `_take_slot` calls `_save_state` synchronously (mkdir + write + os.replace) on the loop on every greet.
+**Fix:** `await asyncio.to_thread(self._save_state)` or batch/debounce.
+**Verification:** unverified — over cap.
+
+### [LOW] SleepDreamer / DanceReflector dereference event.data without None-guard, crashing the consumer loop
+**File:** `dotty-behaviour/consumers/sleep_dreamer.py:166-168`; `dance_reflector.py:89-92`
+**Issue:** Direct `.get` on `event.data`; a `data=None` frame raises AttributeError caught only by the OUTER try/except, which logs "crashed" and EXITS the consumer permanently.
+**Fix:** Use `(event.data or {}).get(...)`; wrap per-event handling so one bad frame doesn't terminate the loop.
+**Verification:** unverified — over cap.
+
+### [LOW] HouseholdRegistry.get_by_calendar_prefix only matches with bracketed YAML; Person.days_until_birthday Feb-29 drift
+**File:** `dotty-behaviour/household/registry.py:190-200, 293-294` (prefix); `82-92` (birthday)
+**Issue:** The prefix index stores the raw YAML value but the query is bracket-normalized, so an unbracketed `calendar_prefix` is unreachable. A Feb-29 birthdate silently shifts to Feb-28 in common years, firing the birthday greeting a day early.
+**Fix:** Bracket-normalize both sides; decide and document a deliberate Feb-29 policy.
+**Verification:** unverified — over cap.
+
+### [INFO/QUALITY] Inconsistent None-guarding; convoluted day-GC expression
+**File:** `dotty-behaviour/consumers/sleep_dreamer.py:167` / `dance_reflector.py:90`; `greeter/greeter.py:226-227`
+**Issue:** None-guard inconsistency across consumers (also flagged above); the day-GC `{today: self._state.get(today, {})}` is provably `{today: {}}` and misleads readers.
+**Fix:** Give `PerceptionEvent.data` a default_factory or guard uniformly; simplify the GC expression with a comment.
+**Verification:** unverified — over cap.
+
+---
+
+## dotty-pi-ext voice tools (TypeScript)
+
+### [HIGH] memory_lookup FTS search bypasses the #53 kid-safety namespace gate
+**File:** `dotty-pi-ext/src/lib/brain_db.ts:82-90` (leaked into `tools/memory_lookup.ts`)
+**Issue:** `fetchPersonMemories` is scoped to `person:<id>` and deliberately never returns `person_pending:<id>` (unreviewed minor facts), but `searchMemories` runs a bare `WHERE memories_fts MATCH ?` over ALL rows, so a pending fact about a minor ("kiddo is allergic to peanuts") is returned to a live turn whenever the query phrase-matches. The oracle (bridge.py) is equally unfiltered, so the gap exists in both.
+**Fix:** Add `AND m.namespace NOT LIKE 'person_pending:%'` to the FTS query; mirror into oracle.py; add a regression test.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] Admin/behaviour HTTP clients disarm the timeout before reading the body
+**File:** `dotty-pi-ext/src/lib/xiaozhi_admin.ts:33-46`; `dotty-pi-ext/src/lib/dotty_behaviour.ts:20-37`
+**Issue:** `adminFetch`/`behaviourFetch` clear the AbortController timer in `finally` after `await fetch()` (headers), then callers do an un-timed `.json()`/`.text()`; a server that sends headers then stalls the body hangs the voice tool forever with no exception, so the try/catch fallbacks never run. The sibling `llama_swap.ts` does this correctly.
+**Fix:** Keep the timer armed across the body read (move the body read inside the fetch helper, mirroring `llama_swap.ts`).
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] turn_logger.formatTurnLog omits the final strip the oracle applies
+**File:** `dotty-pi-ext/src/lib/turn_logger.ts:98-102`
+**Issue:** The oracle stores `content.strip()` of the assembled string; the TS version doesn't, so a user-only turn produces `"user: hello | assistant: "` (trailing space) vs the oracle's stripped form — every user-only turn stores a non-byte-identical row. The integration test that would catch it (`assistant_empty_user_only`) only runs when `DOTTY_BRAIN_DB_SNAPSHOT` is set, which `npm test` never sets.
+**Fix:** `return (\`user: ${u} | assistant: ${a}\`).trim();`; wire the Layer-2 pass into `npm test`.
+**Verification:** unverified — over cap.
+
+### [LOW] play_song caches an empty catalogue on transient fetch failure for 60s
+**File:** `dotty-pi-ext/src/tools/play_song.ts:83-90`
+**Issue:** `getCatalog` caches `fetchSongCatalog`'s `[]` (which means "no songs" OR "fetch failed") for the full 60s TTL, so a momentary xiaozhi blip pins "(catalogue is empty)" for up to a minute.
+**Fix:** Cache only non-empty results; treat empty as a non-cacheable miss.
+**Verification:** unverified — over cap.
+
+### [LOW] play_song matchSong: empty stem from a dotfile matches any query, diverging from the oracle
+**File:** `dotty-pi-ext/src/tools/play_song.ts:39-74`
+**Issue:** A leading-dot catalogue entry yields stem `''`, and `qStem.includes('')` is always true, so the dotfile matches every query and can win — Python's `splitext('.mp3')` keeps `.mp3`, so the implementations disagree, violating the byte-equal contract.
+**Fix:** Only strip an extension when the dot index > 0; guard against an empty stem; add a leading-dot fixture.
+**Verification:** unverified — over cap.
+
+### [LOW] think_hard truncates by UTF-16 code units, diverging from the oracle and sibling tools
+**File:** `dotty-pi-ext/src/tools/think_hard.ts:72-77`
+**Issue:** `.slice(0, 500)` cuts by code units while the oracle and the other tools use codepoint slicing; an emoji-prefixed near-cap reply mis-cuts. think_hard is the lone inconsistent path.
+**Fix:** Use `Array.from(...)` codepoint slicing like the sibling tools.
+**Verification:** unverified — over cap.
+
+### [LOW] play_song host-presence guard ignores the _XIAOZHI_HOST fallback
+**File:** `dotty-pi-ext/src/tools/play_song.ts:104`
+**Issue:** The guard checks only `XIAOZHI_HOST`, but the admin client also honors `_XIAOZHI_HOST`; the two layers disagree on "host configured".
+**Fix:** Use the same precedence as the admin client, or drop the guard and let the empty-list fallback drive the message.
+**Verification:** unverified — over cap.
+
+### [LOW] extractTurnText concatenates assistant text blocks with no separator
+**File:** `dotty-pi-ext/src/lib/turn_logger.ts:56-62, 79-91`
+**Issue:** Multi-message/multi-block assistant turns join with `""`, fusing fragments ("Let me check…The answer is 4") in the logged turn.
+**Fix:** Join with a space/newline.
+**Verification:** unverified — over cap.
+
+### [LOW] think_hard default model resolved at module load, diverging from the per-call oracle
+**File:** `dotty-pi-ext/src/tools/think_hard.ts:25`
+**Issue:** `DEFAULT_MODEL` reads `VOICE_THINKER_MODEL` once at import; the oracle reads it per call, so a later env change diverges the request body.
+**Fix:** Resolve the env lazily inside `buildThinkRequest`.
+**Verification:** unverified — over cap.
+
+### [LOW] play_song getCatalog TOCTOU lets concurrent turns both refetch
+**File:** `dotty-pi-ext/src/tools/play_song.ts:83-90`
+**Issue:** Two interleaved `play_song` calls both see the stale timestamp and both fetch; combined with the empty-cache bug, one can poison the other.
+**Fix:** Store an in-flight promise so concurrent callers await the same fetch; cache only non-empty success.
+**Verification:** unverified — over cap.
+
+### [DOC/QUALITY/LOW–INFO] Stale ZeroClaw comments; take_photo 300-char cap claim; turn_logger "background write" wording; brain_db WAL/handle-staleness; take_photo test not run
+**File:** `dotty-pi-ext/src/lib/brain_db.ts:5,44-46,176,42-52,32-52`; `src/tools/take_photo.ts:1-9`; `src/lib/turn_logger.ts:104-128`; `package.json:17-26`
+**Issue:** brain_db comments still claim ZeroClaw co-writes (now the extension is the sole writer); take_photo's "capped at 300 chars" cap lives server-side, not in the TS client; turn_logger claims a background write but the sqlite INSERT is synchronous inline; brain_db's "WAL concurrency" comment never enables WAL and relies on the default busy_timeout; cached handles go stale if brain.db is swapped under a running process; `tests/take_photo.test.ts` exists but `npm test` never runs it.
+**Fix:** Update the comments to the post-#36 reality; add the take_photo test to the aggregate; either enable WAL or fix the comment; document the no-swap-under-running-process contract.
+**Verification:** unverified — over cap.
+
+---
+
+## StackChan firmware (ESP32-S3 C++/ESP-IDF)
+
+### [MEDIUM] Face recognizer reads the camera frame buffer after releasing the arbiter (latent UAF)
+**File:** `firmware/firmware/main/stackchan/face/face_detector.cpp:236-292`
+**Issue:** `processFrame()` releases the detection arbiter at :236 but still uses the raw V4L2 `frame_data` (captured at :183) afterward — stored into `face_img.data` (:277) and passed to `recognize()` (:292). Once released, the capture path can dequeue/requeue the buffer and overwrite it. The stub ignores the data today, but the planned ESP-DL embedding crop will make this a live use-after-free across two camera tasks.
+**Fix:** Hold the detection lock across `recognize()`, or copy the bounded crop while still holding the arbiter and point `face_img.data` at the copy.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] SoundLocalizer high-pass filter state goes stale during cooldown, producing a spurious spike
+**File:** `firmware/firmware/main/stackchan/sound_localizer.cpp:19-23, 44-51`
+**Issue:** `OnStereoFrame()` returns early on the cooldown gate before advancing the HPF state, so the stored x[n-1]/y[n-1] freeze for up to 750 ms; the first post-cooldown frame evaluates across that discontinuity, injecting a transient that can push energy past threshold and fire a spurious direction change.
+**Fix:** Advance the HPF state every frame regardless of the gates (or prime `_hp_*_prev_x` to the current input on cooldown).
+**Verification:** unverified — over cap.
+
+### [MEDIUM] ImuEventModifier steals and releases the shared modify-lock it may not own
+**File:** `firmware/firmware/main/stackchan/modifiers/imu.h:58-61, 117, 79, 105`
+**Issue:** IMU sets the motion lock only if not held, but `restore_state()` always clears it; if `Capture()` holds the lock to keep the head still for the shutter, a shake's restore releases Capture's lock mid-photo, letting the head move. The avatar lock has the same shape.
+**Fix:** Give the lock real ownership (refcount/owner-token), or have IMU remember whether it acquired it and only release if so.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] FaceDetector::stop() frees buffer and deletes the stop-semaphore without checking the take succeeded — UAF on overrun
+**File:** `firmware/firmware/main/stackchan/face/face_detector.cpp:100-117`
+**Issue:** `stop()` ignores the `xSemaphoreTake(_stop_sem, 2000ms)` return, then unconditionally deletes the semaphore and frees `_rgb_buffer`; if the task overruns the 2s timeout it later gives a deleted semaphore and uses freed state. Currently unwired but a real teardown defect.
+**Fix:** Capture the take result; only delete/free when it succeeded.
+**Verification:** unverified — over cap.
+
+### [LOW] Seqlock reader can return a torn read on weak memory (missing acquire barrier before the second seq load)
+**File:** `firmware/firmware/main/stackchan/face/face_detection_result.h:33-47`
+**Issue:** `read()` loads s1 (acquire), copies plain data fields, loads s2 (acquire) — but an acquire load doesn't forbid the earlier data reads from sinking below the s2 load, so a torn read can pass the seq check. The writer side is correct; the reader is missing the symmetric barrier.
+**Fix:** Insert `std::atomic_thread_fence(std::memory_order_acquire)` between the data copies and the second seq load.
+**Verification:** unverified — over cap.
+
+### [LOW] Idle-channel proactive reconnect churns close+reopen every ~30 ticks
+**File:** `firmware/firmware/patches/xiaozhi-esp32.patch:23-32`
+**Issue:** The reconnect fires on `IsTimeout()` (time-since-last-incoming, 120s); a reopened quiet-but-healthy channel keeps `IsTimeout()` true, so it close+reopens every 30 ticks indefinitely, each iteration paying a 200ms delay + full TLS/WS handshake on the main task.
+**Fix:** Gate on an actual dead-channel signal or a backoff; reset the incoming-frame clock on `OpenAudioChannel()`.
+**Verification:** unverified — over cap.
+
+### [LOW] CloseAudioChannel() blocks the calling task 200ms on every close
+**File:** `firmware/firmware/patches/xiaozhi-esp32.patch:582`
+**Issue:** An added `vTaskDelay(200ms)` stalls whatever task calls close (incl. the main Run loop), compounding the reconnect churn.
+**Fix:** Move the drain delay to only the reopen path that needs it, or make close async.
+**Verification:** unverified — over cap.
+
+### [LOW] PrivacyLeds::update() non-atomic RMW races the guard's setMicState(Off), latching the listening LED on
+**File:** `firmware/firmware/main/stackchan/privacy/privacy_leds.cpp:49-60`
+**Issue:** `update()` load→derive→store of `_mic_state` isn't atomic as a unit; the codec-close dtor can set Off in the window and `update()` overwrites it, so the green mic LED keeps showing "listening" after the mic closed (privacy over-indication).
+**Fix:** Use a CAS that only updates while non-Off so a concurrent Off isn't resurrected.
+**Verification:** unverified — over cap.
+
+### [LOW] CameraPeripheralGuard ctor-fallback/dtor-normal mismatch underflows the refcount
+**File:** `firmware/firmware/main/stackchan/privacy/camera_peripheral_guard.cpp:40-66, 68-86`
+**Issue:** The null-mutex ctor fallback doesn't increment `g_refcount`, but the dtor unconditionally `fetch_sub(1)`; a ctor-fallback/dtor-normal mismatch underflows uint32 to UINT32_MAX, so the stream never tears down and the camera LED stays Active indefinitely.
+**Fix:** Track per-guard `_incremented`; only `fetch_sub` if it incremented; clamp against underflow.
+**Verification:** unverified — over cap.
+
+### [LOW] MCP take_photo arms a fixed 10s camera-glow timer decoupled from capture duration
+**File:** `firmware/firmware/patches/xiaozhi-esp32.patch:523`
+**Issue:** `setCameraLedActive(true, 10000)` is cosmetic but hardcoded to 10s with no off-call; the glow lingers after a fast capture or goes dark before a slow one, no longer tracking the real camera lifecycle.
+**Fix:** Tie the glow to the capture scope (no timeout; clear after Capture, or drive from the guard refcount).
+**Verification:** unverified — over cap.
+
+### [LOW] Unescaped name/session_id in Protocol::SendEvent JSON construction
+**File:** `firmware/firmware/patches/xiaozhi-esp32.patch:537-542`
+**Issue:** The frame is built by raw concatenation; neither `name` nor server-supplied `session_id_` is escaped. Not currently exploitable (literal names, pre-escaped data), but any future runtime name or a quoted session id emits malformed JSON the relay drops.
+**Fix:** Build with cJSON (escapes both); validate `data_json` parses; or assert+escape.
+**Verification:** unverified — over cap.
+
+### [LOW] Debug log leftovers fire at WARN/ERROR on every WS and LLM frame
+**File:** `firmware/firmware/patches/xiaozhi-esp32.patch:65, 590`
+**Issue:** An `ESP_LOGW` on every LLM frame and an `ESP_LOGE` on every inbound WS frame bypass log-level filtering, spam serial, and bury real errors.
+**Fix:** Drop or demote to `ESP_LOGD`.
+**Verification:** unverified — over cap.
+
+### [LOW] HeadPet/Imu cross-task gesture flags are plain volatile bool, not atomic; fixed Press-before-Release order can invert fast sequences
+**File:** `firmware/firmware/main/stackchan/modifiers/head_pet.h:50-52` (and `head_pet.cpp:48-83`, `imu.h:124`)
+**Issue:** `volatile bool` flags written from the signal callback and read+cleared on the tick task aren't atomic (a gesture can be lost), and processing press→swipe→release in fixed order can end with `_is_touched=false` on a fast release-then-press, silently never arming the hold-to-listen window.
+**Fix:** Use `std::atomic<bool>` with `exchange(false)`, or an ordered event queue.
+**Verification:** unverified — over cap.
+
+### [LOW] ParentalGate unlock at millis()==0 treated as "never unlocked"
+**File:** `firmware/firmware/main/stackchan/face/parental_gate.cpp:43, 71-72`
+**Issue:** `_unlocked_at_ms` uses 0 as the "never" sentinel; an unlock in the first ms after boot stores 0 and is silently dropped. Dormant scaffold but a latent collision.
+**Fix:** Use a separate `_is_unlocked` flag, or store `max(now,1)`.
+**Verification:** unverified — over cap.
+
+### [LOW] CameraArbiter::acquireForCapture clears the shared _capture_pending on timeout
+**File:** `firmware/firmware/main/stackchan/face/camera_arbiter.cpp` (header :38-44)
+**Issue:** `_capture_pending` is a single shared atomic, not per-call; a future second capture path plus a timeout could drop both callers' intent, wedging the other's still-pending capture — the TOCTOU the flag exists to prevent.
+**Fix:** Make `_capture_pending` a refcount, or document+assert single-caller.
+**Verification:** unverified — over cap.
+
+### [QUALITY/DOC/LOW–INFO] PrivacyLeds doc/comment drift; dead FaceRecognizer members
+**File:** `firmware/firmware/main/stackchan/privacy/privacy_leds.{h,cpp}` (h:15-19,137-141; cpp:64-65,89); `face/face_recognizer.h:172-173`
+**Issue:** Header docs describe MIC LEDs as white (actually green) and the self-test as amber→cyan→red (actually green→red→off); inline comments say the hal guard "rejects 6/7" and the camera LED is at "index 7" (actually 6/11, camera at kCameraLedIndex=11); `_last_recognize_ms`/`_last_identity` are dead members.
+**Fix:** Update the docs/comments to match the implementation; delete the dead members.
+**Verification:** unverified — over cap.
+
+---
+
+## Top-level + scripts (receiveAudioHandle, dances, scripts/, provision)
+
+### [HIGH] provision.py: voice "General" collides with text "general" and gets moved on every run
+**File:** `community/discord/provision.py:93-96, 197-202`
+**Issue:** `find_channel` searches the whole guild case-insensitively and ignores channel type, so syncing the VOICE "General" matches the existing TEXT "general" and `existing.edit(category=VOICE)` MOVES #general into the VOICE category (destructive, recurs every run); the real voice channel is never created.
+**Fix:** Scope `find_channel` by channel type (compare (name, type) tuples); never move a channel whose type doesn't match.
+**Verification:** confirmed 2/3 lenses.
+
+### [HIGH] dotty_doctor model checks look under data/models instead of repo-root models — false FAIL
+**File:** `scripts/dotty_doctor.py:128-155`
+**Issue:** With config at `data/.config.yaml`, `root = config_path.parent` is `data/`, so the checks look for `data/models/...` while the models actually live at repo-root `models/` — both checks FAIL and the doctor exits non-zero on a healthy standard deploy.
+**Fix:** Don't anchor to `config_path.parent`; if it's a `data/` dir use the parent, or search both `root/models` and `root.parent/models`.
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] startToChat: missing "language" key throws KeyError and feeds raw JSON to the pipeline
+**File:** `receiveAudioHandle.py:1057-1063`
+**Issue:** `_language_tag = data["language"]` (subscript) inside a try that swallows KeyError; when speaker+content are present but language is absent, `actual_text` stays the RAW JSON envelope and gets run through ASR corrections/intent/LLM, and `current_speaker` is never set.
+**Fix:** `data.get("language")`.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] provision.py: read-only permission overwrites never re-applied to existing channels
+**File:** `community/discord/provision.py:197-202`
+**Issue:** The existing-channel branch fixes only the category and `continue`s, never applying overwrites, so READ_ONLY channels that already exist keep `@everyone` send_messages — the script isn't idempotent for permissions on a public server.
+**Fix:** Compute and `existing.edit(overwrites=ov)` in the existing branch when non-empty.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] dotty_doctor check_http treats 404 (and all <500) as pass for the OTA endpoint
+**File:** `scripts/dotty_doctor.py:166-168`
+**Issue:** A 404 on `/xiaozhi/ota/` — exactly the misconfiguration the doctor exists to catch — is reported as PASS.
+**Fix:** Treat 2xx/3xx as pass; flag 4xx as warn/fail with the status code.
+**Verification:** unverified — over cap.
+
+### [MEDIUM] MCP JSON-RPC request ids collide for calls in the same millisecond
+**File:** `receiveAudioHandle.py:281, 319, 349, 373, 399, 456, 559`
+**Issue:** Every MCP id is `int(time.time()*1000) % 0x7FFFFFFF`; back-to-back sends (e.g. two `set_toggle`, or HEAD+LED at the same timeline mark) get identical ids, so a relay correlating by id can mismatch/drop responses.
+**Fix:** Use a monotonic per-connection counter via a shared `_next_mcp_id(conn)` helper.
+**Verification:** unverified — over cap.
+
+### [LOW] dotty_doctor passes Piper without the required .onnx.json config pair
+**File:** `scripts/dotty_doctor.py:146-155`
+**Issue:** The check globs only `*.onnx`; a missing/stub `.onnx.json` (the exact corrupt-download failure the SenseVoice check was hardened against) still reports green PASS while the TTS provider crashes at runtime.
+**Fix:** For each `*.onnx`, assert the sibling `*.onnx.json` exists above a byte floor.
+**Verification:** unverified — over cap.
+
+### [LOW] render_singing_sinsy crashes with ZeroDivisionError on empty/all-comment lyrics
+**File:** `scripts/render_singing_sinsy.py:89`
+**Issue:** `syllables[i % len(syllables)]` with `len==0` raises an opaque traceback when the lyrics file is empty/comments-only; the notes list is guarded but syllables isn't.
+**Fix:** Add a `if not syllables:` guard mirroring the notes guard.
+**Verification:** unverified — over cap.
+
+### [LOW] _send_led_color swallows all exceptions silently
+**File:** `receiveAudioHandle.py:285-286`
+**Issue:** A bare `except Exception: pass` with no log; a broken WS during a dance silently no-ops every LED update, making "dance ran but no lights" undebuggable.
+**Fix:** Log (warn-once) like `_send_led_multi`.
+**Verification:** unverified — over cap.
+
+### [LOW] _encode_midi_to_opus forces ALL set_tempo events to one value
+**File:** `receiveAudioHandle.py:850-857`
+**Issue:** Rewriting every tempo event to one value flattens intended tempo changes; benign for the current registry, latent for any song with tempo automation.
+**Fix:** Rewrite only the first/global tempo, or scale all tempos by the same ratio.
+**Verification:** unverified — over cap.
+
+### [LOW] _handle_dance: singing stream task untracked, so a new utterance cancels choreography but not the audio
+**File:** `receiveAudioHandle.py:789-802, 1092-1096`
+**Issue:** Choreography is tracked and cancelled on the next turn; the singing audio task handle is never stored, so on barge-in it stops only if it observes `client_abort` flip between 60ms packets — fragile, no explicit cancel.
+**Fix:** Store `conn._singing_task` and cancel it alongside `_dance_task`.
+**Verification:** unverified — over cap.
+
+### [LOW] Idle end-prompt re-enters the full intent pipeline via startToChat
+**File:** `receiveAudioHandle.py:1208-1211`
+**Issue:** The idle-timeout end-prompt is fed through `startToChat`, which runs state/dance/vision detection; a customised prompt containing "dance"/"sleep"/a vision phrase fires that side-effect at the moment the connection is closing.
+**Fix:** Submit the end-prompt directly to the LLM, bypassing intent detection (or add a skip flag for system prompts).
+**Verification:** unverified — over cap.
+
+### [LOW] provision.py create_forum drops the computed permission overwrites
+**File:** `community/discord/provision.py:204-213`
+**Issue:** The FORUM branch omits `overwrites=ov`; benign today (no forum in READ_ONLY) but silently no-ops a future read-only forum lockdown.
+**Fix:** Pass `overwrites=ov` to `guild.create_forum`.
+**Verification:** unverified — over cap.
+
+### [QUALITY/LOW] Dead _write_smart_mode_state; stale ZeroClaw docstrings; redundant JSON re-parse; shared-list in-place sort; unreachable _encode_song_to_opus
+**File:** `receiveAudioHandle.py:75-81, 634/644/651, 1054-1063/1114-1119, 761-762/928`; `dances.py:111-112, 302`
+**Issue:** `_write_smart_mode_state` is never called (xiaozhi side is read-only by design); `_with_room_view_marker` docstring still describes the retired "zeroclaw `_payload`"; `actual_text` is JSON-re-parsed a second time after it's already unwrapped; `_macarena_moves` returns the shared module-global list that `resolve_timeline` sorts in place; `_encode_song_to_opus` (WAV path) is unreachable because every registry entry is `.mid`, so rendered singing `.wav` never plays.
+**Fix:** Delete dead code; fix stale docstrings to name PiVoiceLLM; drop the redundant parse; return `list(_MACARENA_TIMELINE)`; wire a `.wav` registry entry or remove the WAV path.
+**Verification:** unverified — over cap.
+
+---
+
+## docs: architecture, internals, setup, operations, policy
+
+### [HIGH] disable-kid-mode.md references non-existent _content_filter and _ensure_emoji_prefix as active
+**File:** `docs/cookbook/disable-kid-mode.md:43-44`
+**Issue:** The doc claims `_content_filter` and `_ensure_emoji_prefix` "remain active in both modes"; neither symbol exists anywhere (the only content filter, planned per #138, lives unused in bridge/text.py; `_ensure_emoji_prefix` was ZeroClaw-era). Emoji enforcement is now in `textUtils.build_turn_suffix()` / the `ALLOWED_EMOJIS` fallback in openai_compat.py.
+**Fix:** Delete the sentence; replace with the real enforcement points and note there is no content-word filter yet (#138).
+**Verification:** confirmed 3/3 lenses.
+
+### [HIGH] disable-kid-mode.md tells the user to restart the bridge, but kid mode is read by xiaozhi-server
+**File:** `docs/cookbook/disable-kid-mode.md:19`
+**Issue:** Kid mode drives the live voice path via `pi_voice._read_kid_mode()` (and openai_compat) running inside the xiaozhi-server container; restarting only the bridge won't change the suffix.
+**Fix:** Change to `docker compose restart xiaozhi-server`; mention the dashboard's live toggle as the no-restart alternative.
+**Verification:** confirmed 3/3 lenses.
+
+### [MEDIUM] Tool count says 'five voice tools'; there are seven (recall_person/remember_person, #53)
+**File:** `docs/brain.md:12,58-68`; `docs/voice-pipeline.md:74`; `docs/llm-backends.md:131-145,22`; `docs/COMPATIBILITY.md:16-18`; `COMPATIBILITY.md:18`; `docs/architecture.md:125,151,239`; `docs/protocols.md:249`; `docs/latent-capabilities.md:66`; `docs/modes.md:175`
+**Issue:** Ten+ docs undercount the dotty-pi-ext tools as five and omit recall_person/remember_person (registered in `src/index.ts:21-27`). COMPATIBILITY.md also pins firmware v1.2.4 while the submodule is at fw-v1.3.1.
+**Fix:** Update every "five voice tools" reference to seven with the full list; bump the firmware version.
+**Verification:** confirmed 2/3 (brain.md, voice-pipeline.md, COMPATIBILITY, architecture, protocols, modes) / 3/3 (latent-capabilities).
+
+### [MEDIUM] architecture.md claims smart-mode model swap is 'now handled in PiVoiceLLM' — it isn't
+**File:** `docs/architecture.md:175`
+**Issue:** PiVoiceLLM has no smart-mode/model-swap logic; bridge.py and brain.md/modes.md all say the swap is unwired v2 scope.
+**Fix:** Replace with "Smart-mode model swap is v2 scope and NOT wired on the PiVoiceLLM path."
+**Verification:** confirmed 2/3 lenses.
+
+### [MEDIUM] Other architecture/protocol doc drift (shared_llm, /api/voice/escalate, port 8000, ZeroClaw paths)
+**File:** `docs/architecture.md:248,172-176`; `docs/protocols.md:292`; `docs/voice-mode-entry.md:40`; `docs/cookbook/add-emoji.md:8-37`; `docs/troubleshooting.md:86`; `docs/proactive-greetings.md:66/83,129-157`
+**Issue:** `shared_llm singleton` was removed with Tier1Slim; `/api/voice/escalate` does not exist (not "non-functional"); inject-text is on 8003 not 8000; add-emoji.md edits bridge.py for symbols that live in textUtils.py (and never mentions EMOJI_MAP, the load-bearing edit); troubleshooting.md maps a directory mount where compose mounts a file; proactive-greetings.md points all code refs at retired `bridge/` paths and gives a wrong `GREETER_PER_DAY_MAX` default.
+**Fix:** Repoint each to the real symbol/path/port; rewrite add-emoji.md around `textUtils.py` + `EMOJI_MAP`.
+**Verification:** confirmed 2/3 (proactive-greetings Files) / others unverified — over cap.
+
+### [LOW] Misc doc nits (container name `bridge` vs `dotty-bridge`, persona source, missing scripts/backup.sh, README section, SceneSynthesisLoop, taxonomy, /admin table, observability metric)
+**File:** `SETUP.md:33`; `docs/troubleshooting.md:135,138`; `docs/COMPATIBILITY.md:60`; `COMPATIBILITY.md:59`; `CLAUDE.md:48`/`SETUP.md:9`/`CONTRIBUTING.md:32,70`; `docs/architecture.md:216`/`modes.md:13,202`; `docs/interaction-map.md:65`; `docs/architecture.md:172-176`; `docs/observability.md:74-84`; `docs/cookbook/change-persona.md:24,47`; `docs/faq.md`/`docs/kid-mode.md`
+**Issue:** `docker logs bridge` should be `dotty-bridge`; `scripts/backup.sh` doesn't exist; the "Configuring for your environment" README section is gone (now `docs/quickstart.md`); the consumer class is `SceneSynthesisLoop`; the modes taxonomy is the six-state mutex; the /admin table omits /state and /persona; observability.md omits the one live metric (`dotty_content_filter_hits_total`); change-persona/faq/kid-mode misattribute the persona source (loaded by the pi agent from `/root/.pi`, not the extension).
+**Fix:** Apply each correction as listed in the per-finding suggestions.
+**Verification:** unverified — over cap.
+
+---
+
+## root + policy docs
+
+### [LOW] CHANGELOG [Unreleased] presents retired ZeroClaw systemd bridge infra as pending
+**File:** `CHANGELOG.md:10`
+**Issue:** The [Unreleased] Added entry describes a `zeroclaw-bridge.service.template` + `scripts/install-bridge.sh` that no longer exist; the bridge now ships as the `dotty-bridge` container.
+**Fix:** Move the entry to the historical ZeroClaw-era section or strike it.
+**Verification:** unverified — over cap.
+
+### [LOW] SECURITY.md threat model cites a retired /api/message bridge endpoint
+**File:** `SECURITY.md:23-24`
+**Issue:** `/api/message` was the ZeroClaw voice endpoint; the bridge registers no such route and its `/admin/*` is localhost-gated. The real unauthenticated LAN surface is xiaozhi-server's `/xiaozhi/admin/*` and dotty-behaviour's `/api/*`.
+**Fix:** Replace the `/api/message` reference with the real surface.
+**Verification:** confirmed 3/3 lenses.
+
+### [LOW] ROADMAP / FAQ / persona docs carry stale Tier1Slim framing
+**File:** `ROADMAP.md:52`; `docs/faq.md:59,73`; `docs/kid-mode.md:50,59,225,297`; `personas/dotty_voice.md` (title)
+**Issue:** ROADMAP frames latency as a "two-tier path" (Tier1Slim removed); FAQ/kid-mode imply `personas/dotty_voice.md` is the live agent persona while the only wired persona is `personas/default.md` (OpenAICompat) and the agent loads from `/root/.pi`; `dotty_voice.md` is still titled "(Tier 1)".
+**Fix:** Reword to the single PiVoiceLLM + think_hard design; clarify the persona mapping; drop the "Tier 1" label.
+**Verification:** unverified — over cap.
+
+---
+
+## monitoring/grafana-dashboard.json (completeness sweep)
+
+### [HIGH] Six of eight dashboard panels query metrics that are never recorded
+**File:** `monitoring/grafana-dashboard.json:107-461, 523-537`
+**Issue:** Only `dotty_kid_mode_active` and `dotty_content_filter_hits_total` are ever written; the first-audio-latency, request-rate, error-rate, smart-mode, perception-events, and calendar-failure panels all render empty on import (7 of 8 panels broken).
+**Fix:** Wire the metrics at their call sites, or trim the dashboard to live panels and add a Content-Filter-hits panel.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] Grafana description + tag still name the retired ZeroClaw system
+**File:** `monitoring/grafana-dashboard.json:18, 629, 660`
+**Issue:** The description says "zeroclaw-bridge ... ACP sessions" and the tags array carries a literal `zeroclaw` tag (polluting Grafana tag search).
+**Fix:** Rename the description, drop the ACP mention, remove the `zeroclaw` tag.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] Active ACP sessions panel queries a dead metric
+**File:** `monitoring/grafana-dashboard.json:266-337`
+**Issue:** Panel id 4 queries `dotty_active_acp_sessions` (defined but never observed; ACP retired in #36), with a red/green threshold that shows a permanently RED "ACP child not respawning" for a subsystem that no longer exists.
+**Fix:** Delete panel id 4.
+**Verification:** confirmed 1/1 lenses.
+
+### [MEDIUM/LOW] monitoring README/observability.md overstate live coverage; metrics.py identity still 'zeroclaw-bridge'
+**File:** `monitoring/README.md:5-7`; `docs/observability.md:8-10,66-84`; `bridge/metrics.py:1,36`
+**Issue:** The docs list 9 metrics as emitted while only 2 are, and omit the one live metric (`dotty_content_filter_hits_total`); the metrics module docstring/logger are still named `zeroclaw-bridge`.
+**Fix:** Mark unwired metrics as "defined, not yet wired", add the content-filter row, rename the logger to `dotty-bridge.metrics`.
+**Verification:** low-sev, unverified.
+
+---
+
+## gap: Emoji-glyph → firmware-emotion contract
+
+### [MEDIUM] add-emoji.md omits the EMOJI_MAP edit and points at stale bridge.py locations
+**File:** `docs/cookbook/add-emoji.md:8-37`
+**Issue:** The only edit that makes a new glyph produce a face is adding it to `EMOJI_MAP` in `custom-providers/textUtils.py` — the doc never mentions it, and instead tells the user to edit `bridge.py` `ALLOWED_EMOJIS`/`_BASE_SUFFIX`, which now live in textUtils.py (and bridge.py is off the voice path). Following it verbatim adds a glyph that passes prompt enforcement but never resolves to an emotion frame.
+**Fix:** Rewrite around textUtils.py: add to `ALLOWED_EMOJIS`, add a glyph→firmware-name entry to `EMOJI_MAP` (matching a `stackchan_display.cc` strcmp branch), update `_BASE_SUFFIX` + the `.config.yaml` prompt, redeploy xiaozhi-server.
+**Verification:** low-sev, unverified.
+
+### [INFO] Emoji→firmware-emotion contract verified intact (no verb-form fallthrough)
+**File:** `custom-providers/textUtils.py:64-90` + `firmware/.../stackchan_display.cc:355-432`
+**Issue:** None — the hypothesised `laugh`/`laughing` mismatch is NOT a bug; `EMOJI_MAP` already emits the gerund/past-tense names the firmware expects, and all 9 protocol emojis resolve end-to-end. `laughing≡happy` and `crying≡sad` collapse by design.
+**Fix:** No code change; optionally document the two intentional collapses.
+**Verification:** low-sev, unverified.
+
+### [LOW] CLAUDE.md says the firmware parses the emoji glyph; the server does
+**File:** `CLAUDE.md:84`
+**Issue:** The firmware reads a pre-resolved english emotion string; the glyph→name translation happens server-side in `get_emotion()`/`EMOJI_MAP`. This imprecision is the conceptual root of the add-emoji.md misdirection.
+**Fix:** Amend to say xiaozhi-server's `get_emotion()`/`EMOJI_MAP` parses the leading emoji into an emotion name and the firmware renders the face.
+**Verification:** low-sev, unverified.
+
+---
+
+## gap: Test-coverage gaps for confirmed bugs
+
+### [HIGH] TTS processed_chars over-count is untested AND the provider package is excluded from coverage
+**File:** `custom-providers/edge_stream/edge_stream.py:67-78`; `custom-providers/piper_local/piper_local.py:114-125`
+**Issue:** Both providers carry the confirmed over-count bug, neither is in `[tool.coverage.run] source`, and no test imports them — so the 56% floor is computed over a source set that physically cannot see these lines; a fix can regress green.
+**Fix:** Fix the bug, add a pure-logic unit test, add both packages to the coverage source and the ci.yml pytest targets.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] OTA _is_higher_version pre-release ordering bug is outside the coverage source set with no covering test
+**File:** `custom-providers/xiaozhi-patches/ota_handler.py:24-43`
+**Issue:** The pure version-compare functions are trivially testable but 0% covered and invisible to the CI floor (xiaozhi-patches is only ruff-linted).
+**Fix:** Replace the digits-only parser with a semver-aware comparator; add a version-table unit test; add the module to coverage and wire a test dir into ci.yml.
+**Verification:** confirmed 1/1 lenses.
+
+### [HIGH] Firmware C++ concurrency code has no native test harness and is invisible to every CI gate
+**File:** `firmware/firmware/main/stackchan/face/face_detection_result.h:19-46` (+ camera path)
+**Issue:** The seqlock torn-read and camera UAF findings have no host/native unit-test target; ci.yml has no firmware build-or-test job, so these subtle-ordering bugs can be refactored with zero signal.
+**Fix:** Stand up a host-native (TSan-enabled) test target for the hardware-free headers (FaceDetectionResult compiles standalone); add a firmware-host-tests job to ci.yml.
+**Verification:** confirmed 1/1 lenses.
+
+### [MEDIUM] openai_compat emoji-prefix + turn-suffix logic untested and excluded from coverage; 56% floor is blind to the high-sev modules
+**File:** `custom-providers/openai_compat/openai_compat.py`; `pyproject.toml:22-33` + `.github/workflows/ci.yml:88-99`
+**Issue:** OpenAICompat (the only PiVoiceLLM fallback) is entirely untested and outside the coverage source, and the `--cov-fail-under=56` gate measures only 3 of the shipped Python modules — every module carrying a confirmed high/medium bug (edge_stream, piper_local, openai_compat, asr, ota_handler) is outside the source set, so the floor provides no regression protection for them.
+**Fix:** Add a streaming-generator unit test for the emoji/suffix logic; expand `[tool.coverage.run] source` + the ci.yml pytest targets as part of each fix; document that the floor is per-source-set.
+**Verification:** low-sev, unverified.
+
+---
+
+## gap: firmware/server/ subtree
+
+### [INFO] firmware/server/ is vendored upstream m5stack Go backend — dead in Dotty, undocumented as such
+**File:** `firmware/server/` (entire subtree)
+**Issue:** The hypothesis that this is live OTA/provisioning that could drift from `ota_handler.py` does NOT hold — `firmware/` is a submodule and `firmware/server/` is the stock m5stack GoFrame social-feed backend vendored inside the fork, referenced nowhere in the parent repo, never built by the ESP-IDF flow, and not COPY'd by any container. The flagged config files are upstream placeholders (GoFrame default ports, boilerplate image prefixes), not Dotty values. The only real issue is navigational: CLAUDE.md never says the submodule carries this unrelated tree, so a reviewer can mistake it for live infra.
+**Fix:** No code change. Add one line to CLAUDE.md's "Firmware iteration" section noting the firmware submodule vendors upstream `server/`/`app/`/`remote/` trees that are NOT part of Dotty's stack; Dotty's OTA is `custom-providers/xiaozhi-patches/ota_handler.py`.
+**Verification:** low-sev, unverified.
+
+---
+
+## Open issues & PRs
+
+| Ref | Disposition | Action |
+|-----|-------------|--------|
+| #104 | still-valid (P1) | Keep open. Implement fix (b): give server-pushed audio its own `server_push_sentence_id`; pair with #105. |
+| #105 | still-valid (P1) | Keep open. Start with SileroVAD threshold bump; then ASR RMS floor / wake-word gating. Triage with #104. |
+| #138 | still-valid (planned) | Keep open. If picked up: lift `content_filter()` into a shared module, gate on kid_mode, wire onto TTS-bound text, red-team on device. |
+| #125 | still-valid | Resolved by PR #139 (deploy-dotty-pi.sh). Keep open until merged. |
+| #98 / #135 | still-valid (speculative) | Keep open. Largely delivered by PR #140 (SenseVoiceOnnx). No urgency — funasr path works. |
+| #60 | still-valid | Keep open. Add docker.sock mount to bridge compose + a CSRF-guarded restart POST. |
+| #21 | still-valid | Keep open. Implement firmware fix (b): re-fire `state_changed` on audio-channel (re)open. |
+| #77 | still-valid (low) | Keep open. Add a CSRF-guarded `/ui/reload-config` for the reload-safe env subset. |
+| #122 | still-valid (tracker) | Keep open as bench tracker. Drain 2-3 checklist items per session; note #39 partially passed. |
+| #121 | still-valid (tracker) | Keep open as firmware observation umbrella. No code action until a symptom recurs instrumentably. |
+| PR #137 | merge | Docs-only AI transparency policy. Verified sound. Optionally fold in the two cosmetic doc nits. |
+| PR #139 | merge | deploy-dotty-pi.sh faithfully mirrors the sibling scripts. Optionally add IMAGE_TAG/node_modules/image-running guards. |
+| PR #140 | changes-needed | Sound SenseVoiceOnnx provider. **Blocker:** fix the Makefile `doctor` to SKIP-when-absent (it hard-fails every default FunASR install). |
+| PR #141 | **close** | De-safety fork mislabeled as a fix (blanks safety suffix, drops system messages, disables perception, adds NSFW+PII persona). Extract only the piper emoji-strip into a standalone PR. |
+
+---
+
+## Recommended priorities
+
+1. **Close PR #141** (F120–F124) — it removes the child-safety guardrails and adds NSFW+PII content to a public kid-safe repo. Highest urgency; no code archaeology needed.
+2. **Break the LAN→host-root chain** (G9): add a docker-socket-proxy + a shared-secret auth gate on `/xiaozhi/admin/*`, confine play-asset to the songs base (G10), and add non-root `USER` to the four Dockerfiles (G11).
+3. **Fix the shipped all-in-one compose** (G18, G19, G21): add the docker.sock + xiaozhi-patches mounts and the VISION_BRIDGE_URL var, or re-scope all-in-one to OpenAICompat-only with an honest header.
+4. **Close the kid-safety leaks**: namespace-guard `memory_lookup` against `person_pending` (F251), run dashboard say/start-story through `content_filter()` (F186), and pursue #138.
+5. **Fix the room_view id/display_name + multi-word name mismatches** (F38/F201, F161/F202) — the entire named-greet feature silently regresses; also de-duplicate the double greeting (F39).
+6. **Fix the TTS truncation bugs** (F148, F26/F27 over-count) and the OTA version comparator (F141), and add them to the coverage source set (G13, G14, G17).
+7. **Un-block the event loop in the bridge** (F128, F185) — wrap blocking HTTP and convo-log parsing in `to_thread` — and exempt `/admin/` from CSRF (F129) so the operator back-channel works.
+8. **Fix the dotty-pi-ext HTTP client timeout-before-body bug** (F212) — a stalled body wedges the whole voice turn — and the dead bridge perception EventSource (F226).
+9. **Repair dotty_doctor** (F257 model path, F51 404-as-pass, F216 Piper config) so `make doctor` is trustworthy on a standard deploy.
+10. **Clean the monitoring dashboard + ZeroClaw/tool-count doc drift** (G1–G4, F76/F77, the "five vs seven tools" sweep) so the docs and the Grafana import match reality.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0f22feb5..3ec70318 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ## [Unreleased]
 
 ### Added
+- **Overnight A/V runner can run unattended** (#182) — opt-in `--mic-opener admin_say` opens the microphone through `/xiaozhi/admin/say` before a warm case; playback is also proven by the robot's own recognition; reference-microphone slips and extra speech in the room are `INCONCLUSIVE` rather than failures; a case the evidence cannot settle is set aside after three attempts. `dotty_av_clips.py export --crop` fills the 9:16 frame from a portrait source region. See `docs/dotty-av-tests.md`.
 - **Kid Mode: blocked-words content filter on the live voice path** (#157, closes the gap tracked in #138) — the pure matcher (three severity tiers + the kid-safe replacement) moved from `bridge/text.py` into the shared `custom-providers/textUtils.py`, the single source of truth both containers import; the bridge keeps its metrics/safety-ring/logging wrapper on top with unchanged behaviour. Both live LLM providers (`PiVoiceLLM`, `OpenAICompat`) now wrap their TTS-bound streams in `filter_tts_stream()`. In Kid Mode it drains and checks the complete response before TTS, then emits the original clean chunks or atomically replaces a blocked turn; outside Kid Mode it remains a transparent streaming passthrough. Full-turn consumption also prevents PiVoiceLLM from abandoning the RPC iterator before `agent_end` and leaking stale frames into the next turn. Honest caveat (see `docs/faq.md`): a word-level blocklist is a weak, bypassable backstop — prompt steering remains the primary defence. **Bench: needs on-device red-team verification before release sign-off.**
 - **Admin-API auth: `X-Admin-Token` across the whole stack** (#149, #150, #151, #152) — xiaozhi-server's `/xiaozhi/admin/*` routes now accept an `X-Admin-Token` shared secret (`DOTTY_ADMIN_TOKEN`, timing-safe compare, permissive when unset), and all three callers — the bridge dashboard, dotty-behaviour's `XiaozhiAdminClient`, and the dotty-pi voice tools' `adminFetch` — send it. The secret is now **plumbed end-to-end**: `make setup` generates one into `.env`, the compose template / all-in-one pass it to xiaozhi-server, the three service compose files document where their copy lives, and `.env.example` + `SETUP.md` §10 describe the enable-everywhere-or-nowhere semantics. Previously the code shipped with no config path, so every deploy silently stayed permissive.
 - **PersonResolver — one answer to "who is this?"** (`dotty-behaviour/household/resolver.py`) — identity resolution was smeared across consumers, and the 2026-06-06 audit found four separate identity bugs because of it. All resolution now funnels through one module with `Person.id` as the canonical key space. Fixed by the consolidation: **room_view roster recognition silently failing whenever `id != display_name`** (the VLM echoes display names; validation compared ids — confirmed 3/3, both the core and greeter paths), **multi-word display names never matching** (the NAME parser was single-token, so "Mary Anne" was a 100% silent miss — confirmed 3/3), **the greeter's calendar lookup dropping a person's own events on a case mismatch** (`[Hudson]` ≠ `hudson` — confirmed 2/3), and **bracketless `calendar_prefix:` YAML never matching**. `summarize_for_prompt` now matches person tags case-insensitively and accepts the resolver's tag set; the room_view test fakes were also fixed to carry real ids (the old fakes re-derived ids from display names, which is exactly what masked the bug).
@@ -26,6 +27,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - **`docs/multi-daemon-split.md`, `docs/advanced/multi-host.md`** — both documented ZeroClaw-host topologies that no longer exist.
 
 ### Fixed
+- **Voice: one abort no longer silences every later reply** (#176) — a device or admin abort set `conn.client_abort` and nothing on the `nointent` chat path cleared it, so ASR and the LLM kept running but no TTS was sent until the robot reconnected. `startToChat` now clears the flag when a new user turn is accepted. Reproduced and verified on the physical robot.
+- **Live voice path now has a Dotty system prompt** (#177) — `PiClient` spawned pi with no `--system-prompt`, so pi's built-in coding-assistant prompt was the only identity the model saw ("I'm just a tiny coding assistant…"). `personas/pi_voice.md` is now passed via `--system-prompt` (`DOTTY_PI_SYSTEM_PROMPT_FILE` overrides; a missing file keeps the old behaviour). The persona also tells the 4B model to answer briefly and stop.
+- **WhisperLocal drops near-silence hallucinations** (#105) — transcripts whose mean `no_speech_prob` exceeds `no_speech_threshold` (default 0.6, `1.0` disables) are discarded instead of being answered ("Thank you." after the robot stops speaking).
+- **Memory: prompt scaffolding is no longer stored or spoken** (#186) — every voice turn was logged to `brain.db` with the per-turn tool-routing and HARD CONSTRAINTS text attached, and an explicit recall ("do you remember…") spoke `memory_lookup`'s raw rows. The turn logger now stores only what the person said, `memory_lookup` cleans older rows at read time, and recall passes the search results to the model as context so the answer is phrased naturally.
+- **think_hard no longer fails on a cold start** (#187) — its request timeout defaulted to 30 s, shorter than the reasoner's 30–50 s cold load, so the first think-hard after an idle period was cancelled mid-load. Default is now 90 s (as the pre-cutover bridge unit had it), the direct tool runner allows 105 s, and Dotty says "Let me think hard about that." before the wait.
+- **PiVoice RPC turns are serialized** (#175, thanks @0Downtime) — one connection can no longer interleave two pi transactions and consume each other's frames.
 - **No-GPU ASR path no longer crash-loops on first run** (#124, #136) — `make fetch-models` was requesting two SenseVoiceSmall filenames that don't exist on Hugging Face (`tokens.json` and `chn_jpn_yue_eng_ko_spectral.fbank.conf.yaml`); the real SentencePiece tokenizer is `chn_jpn_yue_eng_ko_spectok.bpe.model`. Both 404s were silently saved as 15-byte "Entry not found" stubs (curl had no `--fail`), so funasr loaded with `bpemodel=None` and `xiaozhi-esp32-server` crash-looped on every GPU-less host. The file list is corrected; **all `fetch-models` downloads now fail loudly** (`curl --fail --retry` + a size floor + delete-on-failure) instead of saving junk; and **`make doctor` now size-checks the required SenseVoice assets** so a corrupt download FAILs instead of passing. Huge thanks to **[@miltieIV2](https://github.com/miltieIV2)** — a meticulous bug report *and* a self-driven root-cause that pinned it on the `HAS_CUDA=0` FunASR switch. A lighter int8 sherpa-onnx SenseVoice runtime (no PyTorch) for Pi-class hosts has landed as the opt-in `SenseVoiceOnnx` provider (#135; see the Added section above).
 
 ## [server-v0.1.0] - 2026-05-17
diff --git a/CLAUDE.md b/CLAUDE.md
index ee7f4c57..8bfc22d8 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -27,7 +27,7 @@ The voice path runs through a single LLM provider — `PiVoiceLLM`, selected via
 
 ```
                  StackChan hardware → configured persona
-                   │  ESP32-S3, xiaozhi firmware (built from m5stack/StackChan source)
+                   │  ESP32-S3, xiaozhi firmware (pinned BrettKinny/StackChan@dotty fork)
                    │  WiFi / WebSocket (Xiaozhi protocol)
                    ▼
                  xiaozhi-esp32-server (Docker)
@@ -197,7 +197,8 @@ For hardware specs, protocol details, model internals, latent capabilities, and
 
 - xiaozhi-esp32-server: https://github.com/xinnan-tech/xiaozhi-esp32-server
 - xiaozhi-esp32 firmware (upstream): https://github.com/78/xiaozhi-esp32
-- StackChan (hardware + firmware patches): https://github.com/m5stack/StackChan
+- StackChan upstream (hardware + base firmware): https://github.com/m5stack/StackChan
+- Dotty firmware fork (the pinned build source): https://github.com/BrettKinny/StackChan/tree/dotty
 - Emotion protocol: https://xiaozhi.dev/en/docs/development/emotion/
 
 ## Agent skills
diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index 84d56c50..c64bc4fb 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -13,11 +13,16 @@ For protocol wire formats see `docs/protocols.md`.
 
 | Component | Current Version | Protocol / Interface | Breaking Change Policy |
 |---|---|---|---|
-| StackChan firmware (m5stack/StackChan v1.2.4) | v1.2.4 | Xiaozhi WebSocket protocol, MCP over WS (JSON-RPC 2.0) | Pin firmware to a known-good build; do not OTA-update without verifying server compatibility first |
+| StackChan firmware (`BrettKinny/StackChan@dotty`) | `fw-v1.3.3` release; submodule `969c2b2` | Xiaozhi WebSocket protocol, MCP over WS (JSON-RPC 2.0), StateManager event contract | Build the pinned submodule; do not substitute the official upstream tree or OTA-update without coordinated verification |
 | xiaozhi-esp32-server (local build) | `xiaozhi-esp32-server-piper:local` | Custom LLM provider API, `.config.yaml` schema, Xiaozhi WS server | Rebuild image only after checking upstream changelog for provider API or config schema changes |
-| dotty-pi (pi agent) | `dotty-pi:0.1.0` | pi RPC (JSONL over stdio), the five `dotty-pi-ext` voice tools | Pin the image tag; pi-version or model changes need end-to-end cutover testing |
+| dotty-pi (pi agent) | `dotty-pi:0.1.0` | pi RPC (JSONL over stdio), the seven `dotty-pi-ext` voice tools | Pin the image tag; pi-version or model changes need end-to-end cutover testing |
 | dotty-behaviour | `dotty-behaviour:0.1.0` | HTTP API (`/api/perception/*`, `/api/vision/*`, `/api/audio/*`, `/health`) | Endpoint signatures stable; perception event-schema changes require firmware + xiaozhi review |
-| bridge.py (dashboard) | unversioned (HEAD) | `/ui` dashboard, `/admin/*`, `/health` | Dashboard/admin service only post-#36; admin route changes require updating dashboard callers |
+| bridge.py (dashboard) | `dotty-bridge:0.1.0` image from repo HEAD | `/ui` dashboard, `/admin/*`, `/health` | Dashboard/admin service only post-#36; admin route changes require updating dashboard callers |
+
+The public `fw-v1.3.3` superproject tag (commit `24a009c`, 2026-07-12) is the
+current coordinated release pointer. It pins firmware submodule `969c2b2` and
+the matching server-side patches. Draft PRs and a dirty submodule are not a
+released compatibility set.
 
 ## What counts as a breaking change
 
@@ -42,27 +47,28 @@ Any of the following require coordinated updates across components:
 
 ## Versioning strategy
 
-No formal versioning is adopted yet (tracked in
-[ROADMAP.md](ROADMAP.md#community-wishlist) under "Firmware/server
-compatibility matrix"). When adopted, the plan is:
+The repo uses separate tag namespaces:
+
+- `server-vX.Y.Z` for server-only release milestones.
+- `fw-vX.Y.Z` for coordinated firmware release pointers in this superproject.
 
-- Separate tag namespaces: `server-vX.Y.Z` and `fw-vX.Y.Z`.
-- This matrix will document which server versions are compatible with which
-  firmware versions.
-- The bridge will carry its own version once it moves to a tagged release
-  cadence.
+Container image tags remain `0.1.0` today and are not sufficient by themselves
+to identify the exact source revision; retain the Git commit/tag alongside a
+deployment record.
 
 ## Upgrade guidance
 
 1. **Check this matrix first.** Confirm the component you are upgrading is
    compatible with the versions of the other components you are running.
-2. **Back up before upgrading.** Run `scripts/backup.sh` (or the equivalent
-   manual steps) to snapshot config, persona files, and bridge state.
+2. **Back up before upgrading.** Manually snapshot `.env`, rendered
+   `data/.config.yaml`, persona/household files, `brain.db` (including WAL/SHM
+   companions), and the bridge state directory. This repo does not currently
+   ship an automated backup script.
 3. **Upgrade one component at a time.** Validate with a health check
    (`curl http://<XIAOZHI_HOST>:8090/health` and `:8081/health`) plus a live
    voice turn before moving to the next component.
-4. **Tail logs during validation.** Watch both the xiaozhi-server container
-   logs and the bridge journal simultaneously to catch mismatches early.
+4. **Tail logs during validation.** Watch the xiaozhi-server, dotty-pi,
+   dotty-behaviour, and bridge container logs together to catch mismatches.
 5. **Roll back if broken.** Restore from the backup taken in step 2 and
    revert to the previous image or binary.
 
@@ -106,4 +112,4 @@ versions work with which firmware versions.
 
 ---
 
-Last verified: 2026-05-22.
+Last verified against the repository and `fw-v1.3.3` pin: 2026-07-16.
diff --git a/Dockerfile b/Dockerfile
index 08b9caa9..f9748586 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,6 +3,11 @@ FROM ghcr.io/xinnan-tech/xiaozhi-esp32-server@sha256:3accd82a7d1a6c01c58f32f6199
 
 RUN pip install --no-cache-dir piper-tts scipy numpy mido faster-whisper sherpa-onnx==1.13.2
 
+# Patch upstream TTS consumers to treat explicitly registered server-push
+# sentence IDs as independent from chat-turn stale-message arbitration (#104).
+COPY scripts/patch-tts-server-push.py /tmp/patch-tts-server-push.py
+RUN python /tmp/patch-tts-server-push.py /opt/xiaozhi-esp32-server/core/providers/tts
+
 # fluidsynth + General MIDI soundfont for runtime rendering of dance/song MIDI
 # files to Opus. Installed as the LAST layer so iteration on Python deps above
 # doesn't invalidate the soundfont download (~141MB).
diff --git a/Makefile b/Makefile
index 4f798bc0..aa182ebc 100644
--- a/Makefile
+++ b/Makefile
@@ -221,9 +221,10 @@ setup: _preflight-compose ## Interactive first-run wizard (re-runnable; remember
 	 echo -e "$(GREEN)$(BOLD)Setup complete.$(RESET)"; \
 	 echo ""; \
 	 echo "Next steps:"; \
-	 echo "  1. Flash the StackChan firmware (see SETUP.md or m5stack/StackChan repo)."; \
-	 echo "  2. In the device's Advanced Options, set the OTA URL to:"; \
-	 echo "       http://$$XIAOZHI_HOST:8003/xiaozhi/ota/"; \
+	 echo "  1. Build and flash StackChan firmware with this compiled setting:"; \
+	 echo "       CONFIG_OTA_URL=\"http://$$XIAOZHI_HOST:8003/xiaozhi/ota/\""; \
+	 echo "     See SETUP.md. The on-device Settings app has no OTA URL editor."; \
+	 echo "  2. Provision the robot's 2.4 GHz Wi-Fi using its displayed setup flow."; \
 	 echo "  3. Run 'make doctor' to verify everything is healthy."; \
 	 echo ""
 
diff --git a/README.md b/README.md
index df050558..b26d5c1b 100644
--- a/README.md
+++ b/README.md
@@ -36,7 +36,7 @@ Full policy: [`AI_TRANSPARENCY.md`](./AI_TRANSPARENCY.md).
 - **Streaming responses** — the bridge streams LLM output to the voice pipeline for lower perceived latency.
 - **Emoji expressions** — every response starts with an emoji that the firmware maps to a face animation (smile, laugh, sad, surprise, thinking, angry, love, sleepy, neutral).
 - **Voice tools** — the pi agent can search its memory, escalate hard questions to a bigger model, take a photo, and play songs, all mid-conversation.
-- **States, toggles & LEDs** — a six-state mutex (`idle / talk / story_time / security / sleep / dance`) plus two orthogonal toggles (`kid_mode`, `smart_mode`), all owned by the firmware StateManager and surfaced on the 12-pixel LED ring. Shipped on the active firmware fork (commit `d78118b`, 2026-04-27); the `firmware/firmware/` submodule pin in this repo lags, so flash from the active fork to get it. See "States, Toggles & LEDs" below and [`docs/modes.md`](./docs/modes.md).
+- **States, toggles & LEDs** — a six-state mutex (`idle / talk / story_time / security / sleep / dance`) plus two orthogonal toggles (`kid_mode`, `smart_mode`), all owned by the firmware StateManager and surfaced on the 12-pixel LED ring. Shipped on the active firmware fork (commit `d78118b`, 2026-04-27) and included in the release pin checked on 2026-09-12 (`969c2b2`). Later fixes may still differ between the release pin and active fork; see [`docs/modes.md`](./docs/modes.md).
 - **Vision (camera)** — the robot's built-in camera can capture images for multimodal LLM queries.
 - **Privacy LEDs** — hardware-bound mic (green) and camera (red) indicators on the LED ring. They light from the codec/camera enable signals via RAII guards, so a misbehaving server or model can't capture with the lights off.
 - **Calendar context** — optional calendar integration feeds upcoming events into the conversation context.
@@ -46,7 +46,7 @@ Full policy: [`AI_TRANSPARENCY.md`](./AI_TRANSPARENCY.md).
 
 Behaviour is a **six-state mutex** (`idle / talk / story_time / security / sleep / dance`) plus two orthogonal toggles (`kid_mode`, `smart_mode`), all owned by the firmware StateManager (shipped on the active fork in commit `d78118b`, 2026-04-27; bench checks tracked in [#38](https://github.com/BrettKinny/dotty-stackchan/issues/38)). Voice phrases, camera edges, and dashboard controls all flow through it.
 
-> Note: the `firmware/firmware/` submodule pin in this repo deliberately lags the active fork — flashing from the submodule won't give you Phase 4 yet. See the "Firmware iteration" section in [`CLAUDE.md`](./CLAUDE.md) and the submodule-pin caveat in [`docs/modes.md`](./docs/modes.md).
+> Note: `firmware/` is a release pointer, not the active development checkout. The historical `35f701a` pin predates Phase 4; the pin checked on 2026-09-12 (`969c2b2`) includes it. Check your actual revision for subsequent fixes. See the "Firmware iteration" section in [`CLAUDE.md`](./CLAUDE.md) and the submodule-pin caveat in [`docs/modes.md`](./docs/modes.md).
 
 The 12-pixel LED ring shows the current state at a glance. **Left ring 0-5 is the state arc** — all six pixels paint the state colour, matching the dashboard's state buttons:
 
@@ -56,12 +56,12 @@ The 12-pixel LED ring shows the current state at a glance. **Left ring 0-5 is th
 | 🟢 | `talk` — conversation engaged. |
 | 🟠 | `story_time` — long-running interactive story. |
 | ⚪ | `security` — watching the room (1 Hz white flash). |
-| 🔵 | `sleep` — quiescent, mic open for "wake up". |
+| 🔵 | `sleep` — privacy sleep: face detection, voice processing, and wake-word detection off; wake by head touch or explicit dashboard state change. |
 | 🟣 | `dance` — rainbow sweep + choreography. |
 
 On the right ring, **indices 8-9 are toggle pips** for kid_mode (salmon pink) and smart_mode (orange), and **index 11 (bottom) lights red while you have the turn** (LISTENING). The `idle → talk` transition fires on `face_detected` from the firmware; VLM identity recognition runs in parallel and feeds the LLM context.
 
-> Heads up: that right-ring layout is the active-fork StateManager. On the firmware **submodule pinned in this repo**, pixels 6 and 11 instead drive the **privacy LEDs** — 6 = mic (green), 11 = camera (red) — and the StateManager pips arrive once the submodule catches up to the active fork.
+> Heads up: the historical pre-StateManager build (`35f701a`) used a different right-ring layout: 6 = mic (green), 11 = camera (red). The release pin checked on 2026-09-12 already includes StateManager. Interpret indicators against the actual firmware revision, not the old pre-StateManager layout.
 
 Full state taxonomy, colour palette, transition diagram, and per-state backing architecture: [`docs/modes.md`](./docs/modes.md).
 
diff --git a/SETUP.md b/SETUP.md
index fee1f2e6..a775bcdb 100644
--- a/SETUP.md
+++ b/SETUP.md
@@ -48,34 +48,38 @@ There is **no SoftAP captive portal** in stock firmware (some older
 third-party xiaozhi builds had one; the shipped firmware does not).
 
 To run the StackChan **fully self-hosted** (no phone-app account, no vendor cloud,
-your own xiaozhi-server as the endpoint), you need to **reflash the device
-with firmware built from the open source tree**.
-
-The upstream firmware lives at **https://github.com/m5stack/StackChan**:
-- `firmware/` — M5Stack's patches + ESP-IDF project wrapper
-- `firmware/fetch_repos.py` — pulls `78/xiaozhi-esp32` as a dependency and
-  applies StackChan-specific patches, adding the board target
-  `CONFIG_BOARD_TYPE_M5STACK_STACK_CHAN`
+your own xiaozhi-server as the endpoint), reflash it with Dotty's pinned
+`BrettKinny/StackChan@dotty` firmware fork. The official `m5stack/StackChan`
+tree is its upstream, but it does not contain Dotty's state, motion, LED, and
+perception changes.
+
+The StackChan's on-device Settings app has no **Advanced Options** or OTA URL
+editor. The similarly named **Advanced** tab documented by Xiaozhi belongs to
+its browser-based SoftAP captive portal and appears only when that provisioning
+mode is active. The current `fw-v1.3.3` prebuilt is compiled for the
+maintainer's LAN, so another self-hosted deployment must build from source with
+its own `CONFIG_OTA_URL` as shown below.
+
+The exact firmware source is the `firmware/` submodule of this repo. It pins
+`BrettKinny/StackChan@dotty`, whose `firmware/fetch_repos.py` pulls
+`78/xiaozhi-esp32` v2.2.4 and applies the StackChan integration patch.
 
 ---
 
 ## 2. Build and flash open firmware
 
-> **Note — build flow documented from first-pass session findings; not yet
-> end-to-end verified. Will be updated after a successful first flash.**
-
 Requires **ESP-IDF v5.5.4**. Easiest path: the official
 `espressif/idf:v5.5.4` Docker image.
 
 ### 2a. Clone and configure
 
 ```bash
-git clone https://github.com/m5stack/StackChan.git
-cd StackChan/firmware
+git clone --recursive https://github.com/BrettKinny/dotty-stackchan.git
+cd dotty-stackchan/firmware/firmware
 ```
 
 Point the firmware at your xiaozhi-server for OTA. Edit
-`firmware/sdkconfig.defaults` and add (or modify) the line:
+`sdkconfig.defaults` and add (or modify) the line:
 
 ```
 CONFIG_OTA_URL="http://<XIAOZHI_HOST>:8003/xiaozhi/ota/"
@@ -83,10 +87,20 @@ CONFIG_OTA_URL="http://<XIAOZHI_HOST>:8003/xiaozhi/ota/"
 
 Trailing slash matters — that's the path the server exposes.
 
+`sdkconfig.defaults` seeds a newly generated `sdkconfig`; it does not overwrite
+an existing one. On a repeat build, either make the same change through
+`idf.py menuconfig` (**Xiaozhi Assistant → Default OTA URL**) or remove the
+generated `sdkconfig` before rebuilding. Verify the effective value after
+configuration with:
+
+```bash
+grep '^CONFIG_OTA_URL=' sdkconfig
+```
+
 ### 2b. Build inside the IDF container
 
 ```bash
-docker run --rm -it -v "$PWD/..":/project -w /project/firmware \
+docker run --rm -it -v "$PWD":/project -w /project \
   espressif/idf:v5.5.4 \
   bash -c "python3 fetch_repos.py && idf.py build"
 ```
@@ -101,7 +115,7 @@ Linux (`/dev/cu.usbmodem*` on macOS — adapt the `--device` flag).
 
 ```bash
 docker run --rm -it --device=/dev/ttyACM0 \
-  -v "$PWD/..":/project -w /project/firmware \
+  -v "$PWD":/project -w /project \
   espressif/idf:v5.5.4 \
   idf.py -p /dev/ttyACM0 flash
 ```
@@ -111,14 +125,23 @@ flow), use that instead.
 
 ### 2d. First boot after flash
 
-- No pairing-code screen
-- No BLE provisioning step
-- The device boots, loads WiFi credentials compiled into the firmware
-  (or, if you left WiFi unconfigured, whatever fallback the upstream
-  build offers — consult the xiaozhi-esp32 README for the current default
-  behaviour)
-- It POSTs to `http://<XIAOZHI_HOST>:8003/xiaozhi/ota/`, gets back the
-  WebSocket endpoint, and connects
+Seeing **“Welcome! Let's get started.” is expected on a fresh flash**. It is
+the StackChan app-configuration wizard, controlled by an NVS flag; it does not
+mean the compiled `CONFIG_OTA_URL` was ignored.
+
+For a self-hosted setup:
+
+1. Tap **Skip** on the welcome screen. This bypasses the M5Stack account/BLE
+   wizard for the current boot.
+2. If the launcher remains visible, open **SETUP**, then use its home control
+   to exit. Closing SETUP starts the Xiaozhi voice application.
+3. With no saved SSID, the pinned build enters its default Xiaozhi hotspot
+   provisioner. Join the temporary `Xiaozhi-*` Wi-Fi network and open the URL
+   shown on the robot (normally `http://192.168.4.1`).
+4. Select the robot's 2.4 GHz Wi-Fi network. The browser portal also has an
+   **Advanced** tab where you can confirm or override `ota_url`.
+5. After Wi-Fi connects, the device POSTs to the compiled/persisted OTA URL,
+   receives the WebSocket endpoint, and connects.
 
 Tail the server logs while the device boots so you can watch the
 handshake happen (see step 4 below).
@@ -127,18 +150,13 @@ handshake happen (see step 4 below).
 
 ## 3. WiFi credentials
 
-Two options, depending on what the upstream xiaozhi-esp32 build exposes at
-the version you pulled:
+The pinned firmware does **not** define `CONFIG_WIFI_SSID` or
+`CONFIG_WIFI_PASSWORD`; adding those names to `sdkconfig.defaults` has no
+effect. Wi-Fi credentials live in NVS and are supplied through the Xiaozhi
+hotspot portal described above (or retained from an earlier compatible
+provisioning).
 
-- **Compile-time WiFi credentials** — set `CONFIG_WIFI_SSID` and
-  `CONFIG_WIFI_PASSWORD` in `sdkconfig.defaults`. Simplest for a static
-  home setup; easy to forget they're in the binary.
-- **Fallback SoftAP or BLE provisioning** — some upstream builds include a
-  fallback provisioning flow if no credentials are saved. Check the
-  upstream README for what your commit supports.
-
-Either way, the device must land on a **2.4 GHz** network. ESP32-S3 does
-not do 5 GHz.
+The device must land on a **2.4 GHz** network. ESP32-S3 does not do 5 GHz.
 
 ---
 
@@ -234,6 +252,9 @@ Some older xiaozhi builds expose a SoftAP captive portal on first boot:
 If you have a build where this works, it's the fastest provisioning flow.
 It just isn't what M5Stack ships today.
 
+This **Advanced** control is a tab in the browser portal at `192.168.4.1`, not
+an item in the StackChan's on-device Settings app.
+
 ---
 
 ## 9. When it's working: bookmark these
diff --git a/audit-draft-issues.md b/audit-draft-issues.md
new file mode 100644
index 00000000..afa123a3
--- /dev/null
+++ b/audit-draft-issues.md
@@ -0,0 +1,3248 @@
+# Draft GitHub issues — dotty-stackchan audit
+
+Ready-to-file issue drafts for confirmed bugs and all critical/high-severity findings (excluding the issue/PR triage entries, which are tracked in `AUDIT-REPORT.md`). Each block is copy-pasteable into `gh issue create`.
+
+---
+
+## [CRITICAL] Container chain: unauthenticated admin routes + docker.sock + host networking = LAN→host-root
+
+```
+Summary
+An attacker who reaches the LAN (or Tailnet) has a confirmed write primitive into the
+container that holds the docker socket, and that container is one `docker run --privileged`
+call from full host root. The individually-reported symptoms (unauth admin routes,
+arbitrary-path play-asset, all-root containers, host networking) are each one link of a
+single exploit chain.
+
+Location
+docker-compose.yml.template:43-60,59-60,596
+custom-providers/xiaozhi-patches/http_server.py:596,620-672
+dotty-pi/docker-compose.yml:17 / dotty-behaviour/docker-compose.yml:23 / bridge/docker-compose.yml:31
+
+Details
+- xiaozhi-server binds 0.0.0.0:8003 and registers all 11 /xiaozhi/admin/* routes with NO auth.
+- The SAME container mounts /var/run/docker.sock + /usr/bin/docker (the compose comment admits
+  this gives "effective root on the docker host").
+- The other three services run network_mode: host with no segmentation.
+- None of the four Dockerfiles set USER — every container runs as root.
+
+Proposed fix
+Break the chain at more than one link:
+1. Replace the raw docker.sock bind with a least-privilege docker-socket-proxy
+   (tecnativa/docker-socket-proxy) exposing ONLY the exec API PiVoiceLLM needs.
+2. Add a shared-secret bearer-token aiohttp middleware over the /xiaozhi/admin/* subapp
+   (constant-time compare, 401 otherwise); have callers present it.
+3. Bind admin HTTP to 127.0.0.1 (set server.ip) and reach it only from sibling containers
+   on loopback instead of publishing 0.0.0.0:8003.
+4. Add non-root USER directives to all four Dockerfiles. Pair with no-new-privileges:true.
+Do at least the socket-proxy + route auth.
+
+Suggested labels: security, area:xiaozhi, area:bridge, priority:critical
+```
+
+---
+
+## [CRITICAL] compose.all-in-one.yml omits the docker.sock + docker CLI mounts the default PiVoiceLLM provider requires
+
+```
+Summary
+A fresh deploy following compose.all-in-one.yml's own Quick start with the default config
+gets a container that cannot exec into dotty-pi — every voice turn fails.
+
+Location
+compose.all-in-one.yml:64-79
+
+Details
+The shipped .config.yaml.template defaults to selected_module.LLM: PiVoiceLLM, which reaches
+the brain via `docker exec -i dotty-pi pi --mode rpc ...` (pi_client.py:360-368). That needs
+the host docker socket + docker CLI bind-mounted (docker-compose.yml.template:59-60).
+compose.all-in-one.yml mounts the pi_voice provider dir but NOT the socket or the docker
+binary — even though its own header says PiVoiceLLM "requires the host docker socket".
+
+Proposed fix
+Add the two PiVoiceLLM mounts (matching the template):
+  /var/run/docker.sock:/var/run/docker.sock
+  /usr/bin/docker:/usr/bin/docker:ro
+Or, if all-in-one is meant to be OpenAICompat-only, change the shipped selected_module
+default and say so explicitly in the header.
+
+Suggested labels: bug, area:deploy, priority:high
+```
+
+---
+
+## [HIGH] compose.all-in-one.yml is missing the xiaozhi-patches mounts — admin routes + perception relay dead
+
+```
+Summary
+Deploying with compose.all-in-one.yml yields upstream xiaozhi-server with no admin portal and
+no perception relay, so the entire dotty-behaviour layer is inert.
+
+Location
+compose.all-in-one.yml:64-79
+
+Details
+The canonical template mounts portal_bridge.py, websocket_server.py, http_server.py, and
+textMessageHandlerRegistry.py (admin routes, active_connections registry, EventTextMessageHandler).
+all-in-one mounts none of them, so consumers fire admin HTTP calls into 404s and no perception
+events ever reach the bus. Also missing vs the template: openai_compat, personas,
+receiveAudioHandle.py, dances.py, textUtils.py, songs, and the kid/smart state mount.
+
+Proposed fix
+Bring compose.all-in-one.yml's volume list to parity with docker-compose.yml.template, or
+generate the all-in-one from the template so it can't drift. At minimum add the four
+xiaozhi-patches mounts plus openai_compat, personas, receiveAudioHandle, dances, textUtils,
+songs, and VISION_BRIDGE_URL.
+
+Suggested labels: bug, area:deploy, priority:high
+```
+
+---
+
+## [HIGH] All /xiaozhi/admin/* routes are completely unauthenticated
+
+```
+Summary
+Every admin endpoint is registered with no auth check, so anyone reaching port 8003 can drive
+the robot and read arbitrary files.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:620-672 (handlers 34-589)
+
+Details
+inject-text, abort, set-head-angles, set-state, set-toggle, set-face-identified, take-photo,
+play-asset, songs, say, devices — all added with no auth. inject-text runs the full LLM+MCP
+pipeline (remote prompt-injection into the pi agent); say is verbatim TTS; play-asset reads any
+absolute path (only os.path.exists). The OTA and WS paths guard themselves; these do not.
+
+Proposed fix
+Gate the routes behind a shared secret: an aiohttp middleware requiring a Bearer / X-Admin-Token
+header on every /xiaozhi/admin/* request, 401 otherwise. At minimum confine play-asset to an
+allow-listed base dir via os.path.realpath + startswith.
+
+Suggested labels: security, area:xiaozhi, priority:high
+```
+
+---
+
+## [HIGH] play-asset accepts arbitrary absolute filesystem path with no allowlist
+
+```
+Summary
+/xiaozhi/admin/play-asset feeds any readable file to ffmpeg inside the docker.sock-holding
+container, with the only validation being os.path.exists.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:376-411
+
+Details
+asset is a raw absolute path; no base-dir confinement, no extension allowlist before
+AudioSegment.from_file (ffmpeg/libav). The sibling songs handler hard-codes a base dir + a
+{opus,ogg,wav,mp3} allowlist; play-asset has neither. An unauthenticated LAN caller can
+probe arbitrary host/container paths (404-vs-200) and exercise libav demuxer CVEs against
+attacker-staged files — and a decoder RCE lands on the privileged process.
+
+Proposed fix
+Resolve os.path.realpath(asset) and require it to start with the songs base
+(/opt/xiaozhi-esp32-server/config/assets/songs + os.sep) before decode; enforce the
+{opus,ogg,wav,mp3} allowlist; prefer accepting only a basename joined onto the fixed base.
+
+Suggested labels: security, area:xiaozhi, priority:high
+```
+
+---
+
+## [HIGH] All four containers run as root (no USER directive)
+
+```
+Summary
+None of the four service images declare USER; for xiaozhi-server the root process is the one
+mounting docker.sock, so any code-exec bug there is already host root.
+
+Location
+Dockerfile, dotty-pi/Dockerfile, dotty-behaviour/Dockerfile, bridge/Dockerfile
+
+Details
+xiaozhi-server (upstream base), dotty-pi (node:25.9-alpine), dotty-behaviour + bridge
+(python:3.12-slim) all run as root. The FastAPI/uvicorn and pi workloads do not need root.
+dotty-behaviour and bridge run root on host networking, widening blast radius.
+
+Proposed fix
+Add a non-root USER to each Dockerfile (create app user, chown app/state dirs, drop to it).
+For xiaozhi-server, run the socket-proxy so root-in-container is no longer root-on-host.
+Pair with no-new-privileges:true and read-only rootfs where feasible.
+
+Suggested labels: security, area:deploy, priority:high
+```
+
+---
+
+## [HIGH] room_view roster recognition silently fails when person id != display_name
+
+```
+Summary
+A correct VLM identification is dropped to person_id=None whenever a person's canonical id
+differs from display_name.lower() — the common case — so named greetings never fire.
+
+Location
+dotty-behaviour/vision/room_view.py:115-124,159-167
+dotty-behaviour/routes/vision.py:192,256-269
+
+Details
+name_choices is built from p.display_name, but parse_room_view_response validates against
+roster_ids, which household.roster_ids_with_appearance() sources from p.id. For id `hudson_jr`
+with display_name `Hudson`, the lowercased returned name doesn't match roster_ids and falls to
+None; the synthetic face_recognized broadcast never fires. Masked because the test fake
+reimplements the helper as display_name.lower() with id==display_name fixtures.
+
+Proposed fix
+Make the prompt vocabulary and the parser's validation set use the SAME key: build name_choices
+from p.id, or resolve the returned display name back to the canonical id before the membership
+check. Fix the test fake to return p.id and add an id != display_name fixture.
+
+Suggested labels: bug, area:behaviour, area:vision, priority:high
+```
+
+---
+
+## [HIGH] Double greeting on every face_recognized — FaceGreeter and ProactiveGreeter both fire
+
+```
+Summary
+A single face recognition produces two back-to-back utterances because two independent
+consumers both speak and don't coordinate.
+
+Location
+dotty-behaviour/consumers/face_greeter.py:133-186
+dotty-behaviour/greeter/greeter.py:162 (wired in main.py:309-323)
+
+Details
+FaceGreeter._handle_face_recognized says "Oh, it's {name}!" and ProactiveGreeter._on_face_recognized
+independently generates an LLM greeting and also says(). They keep separate cooldown state. The
+bare-greet path was deliberately suppressed when the roster is identifiable; the named path was not.
+
+Proposed fix
+Pick one owner for the named greeting: disable FaceGreeter's named path when the proactive
+greeter is enabled (empty FACE_NAME_GREET_TEMPLATE), or share a single per-identity cooldown
+timestamp between the two so the second consumer backs off.
+
+Suggested labels: bug, area:behaviour, priority:high
+```
+
+---
+
+## [HIGH] room_view name parser cannot match multi-word display names
+
+```
+Summary
+Any roster member whose display name contains a space is a 100% silent identification failure,
+even on a perfect VLM response.
+
+Location
+dotty-behaviour/vision/room_view.py:72-81,115-124
+
+Details
+name_choices injects display_name and the prompt asks for `NAME: <display_name>`, but the NAME
+capture group is `[A-Za-z_][A-Za-z0-9_-]*` — a single whitespace-free token. A reply
+`NAME: Mary Anne` fails the anchored regex, so parse_room_view_response returns (cleaned, None, None).
+
+Proposed fix
+Make the NAME group accept internal spaces (e.g. `[A-Za-z_][\w '\-]*?`) and normalise before
+lookup, OR request a single-token id and map ids->display names. Add a two-word display_name test.
+
+Suggested labels: bug, area:behaviour, area:vision, priority:high
+```
+
+---
+
+## [HIGH] Greeter calendar lookup never matches an identified person (case mismatch)
+
+```
+Summary
+A greeted person's personal calendar items are silently dropped from their greeting unless
+their calendar prefix is all-lowercase.
+
+Location
+dotty-behaviour/greeter/greeter.py:257-259 -> calendar_/cache.py:69-73
+dotty-behaviour/calendar_/fetch.py:99
+
+Details
+summarize_for_prompt is called with person=identity (lowercased id), but the calendar `person`
+field is set from the title prefix with no case folding (`[Hudson] -> "Hudson"`). The filter
+`if ev["person"] != person` then drops "Hudson" against "hudson". Household-bucket events mask it.
+
+Proposed fix
+Normalise both sides: lower-case the parsed calendar person at fetch time (prefer mapping the
+prefix through HouseholdRegistry.get_by_calendar_prefix to the canonical id), or compare
+case-insensitively in summarize_for_prompt.
+
+Suggested labels: bug, area:behaviour, area:calendar, priority:high
+```
+
+---
+
+## [HIGH] memory_lookup FTS search bypasses the #53 kid-safety namespace gate
+
+```
+Summary
+A fact about a minor routed to the person_pending review queue can be returned to a live turn
+by memory_lookup whenever the query phrase-matches it.
+
+Location
+dotty-pi-ext/src/lib/brain_db.ts:82-90 (searchMemories SQL); tools/memory_lookup.ts
+
+Details
+fetchPersonMemories is scoped to person:<id> and deliberately never returns person_pending:<id>
+(unreviewed minor facts). But searchMemories runs a bare `WHERE memories_fts MATCH ? ORDER BY rank`
+over ALL rows in `memories` (external-content FTS over every row), including person_pending:<id>.
+The oracle (bridge.py _voice_memory_search_blocking) is equally unfiltered, so the gap exists in both.
+
+Proposed fix
+Add a namespace guard:
+  ... WHERE memories_fts MATCH ? AND m.namespace NOT LIKE 'person_pending:%' ORDER BY rank LIMIT ?
+Mirror the exclusion into oracle.py/bridge.py. Add a test seeding a person_pending row and
+asserting memory_lookup never returns it.
+
+Suggested labels: bug, safety, area:dotty-pi, priority:high
+```
+
+---
+
+## [HIGH] Mid-utterance synth failure emits SentenceType.LAST, truncating the rest of the reply
+
+```
+Summary
+On any synthesis error in a non-last segment, the provider tells xiaozhi/firmware the whole TTS
+response is finished, so the device stops talking mid-sentence.
+
+Location
+custom-providers/edge_stream/edge_stream.py:139-143
+custom-providers/piper_local/piper_local.py:187-191 (identical bug)
+
+Details
+text_to_speak's except handler unconditionally pushes (SentenceType.LAST, [], None) regardless
+of is_last. A reply is split into multiple segments; if an early/middle segment's synth throws
+(edge_tts blip, Piper decode error), the LAST marker drops every remaining segment.
+
+Proposed fix
+Only emit LAST from the failure path when is_last is True; for non-last segments, log and
+continue (or emit a segment-level failure sentinel) so subsequent segments still play.
+
+Suggested labels: bug, area:tts, priority:high
+```
+
+---
+
+## [HIGH] dotty_doctor model checks look under data/models instead of repo-root models — false FAIL
+
+```
+Summary
+In the standard documented layout (config at data/.config.yaml, models at models/), both
+model checks report FAIL and dotty_doctor exits non-zero even though the models are present.
+
+Location
+scripts/dotty_doctor.py:128-155
+
+Details
+_find_config prefers data/.config.yaml; check_models_* then compute root = config_path.parent
+(= data/) and check data/models/SenseVoiceSmall and data/models/piper. But the models live at
+repo-root models/ (docker-compose mounts ./models/...; Makefile SENSEVOICE_DIR := models/...).
+
+Proposed fix
+Don't anchor to config_path.parent. If config_path is .config.yaml under a data/ dir, use
+config_path.parent.parent; or search both root/models and root.parent/models.
+
+Suggested labels: bug, area:tooling, priority:high
+```
+
+---
+
+## [HIGH] provision.py: voice "General" collides with text "general" and gets moved on every run
+
+```
+Summary
+Syncing the VOICE "General" channel destructively moves the existing TEXT #general into the
+VOICE category, recurring on every idempotent re-run; the real voice channel is never created.
+
+Location
+community/discord/provision.py:93-96,197-202
+
+Details
+find_channel searches the whole guild case-insensitively and ignores channel type, so
+find_channel(guild, "General") matches text "general"; the existing-channel branch then calls
+existing.edit(category=VOICE), moving #general. Same collision class hits any text/voice name
+pair differing only by case.
+
+Proposed fix
+Scope find_channel by the expected channel type (pass kind and filter on isinstance /
+ChannelType), or compare (name, type) tuples. Don't move a channel whose type doesn't match.
+
+Suggested labels: bug, area:community, priority:high
+```
+
+---
+
+## [MEDIUM] Dashboard action endpoints always block 8s and report "no reply" — the event producer is dead
+
+```
+Summary
+Every dashboard Say/Dance/Mood/Story action blocks for the full 8s then renders
+"Sent — no reply in 8s." because nothing ever enqueues onto the bridge event bus.
+
+Location
+bridge.py:613-626 (producer stub); bridge/dashboard.py:658-704,2091-2133
+
+Details
+_inject_or_error subscribes to _dashboard_event_listeners and waits 8s for Dotty's reply, but
+the voice-turn producer moved to dotty-pi in #36 and was never re-wired to the bridge SSE bus.
+The injection fires (device speaks) but the dashboard can never show the reply.
+
+Proposed fix
+Either wire a real producer (dotty-pi/xiaozhi POSTs completed turns to a bridge endpoint that
+calls put_nowait on each subscriber queue), or drop the subscribe/wait and return "Sent"
+immediately. Document /ui/events as heartbeat-only until a producer exists.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] Blocking synchronous HTTP inside async dashboard routes stalls the event loop
+
+```
+Summary
+Uncached dotty-behaviour getters and the robot-photo proxy do synchronous requests.get with no
+to_thread, blocking the entire asyncio loop for up to 1.5-2.0s and freezing all dashboard clients.
+
+Location
+bridge.py:471-504 (_dotty_behaviour_get)
+bridge/dashboard.py:193-218 (_fetch_robot_photo), 1366, 2085, 801, 1925
+
+Details
+The perception/vision/audio getters funnel through _dotty_behaviour_get (requests.get timeout=1.5)
+and are called from async routes with no await. The HTMX 10s poll fans each render into 3-6 such
+calls. The codebase already uses asyncio.to_thread for device-count/songs, so these are clear
+omissions. _build_perception_card_ctx's "no I/O" docstring is now false.
+
+Proposed fix
+Wrap the blocking HTTP in asyncio.to_thread at the call sites, or use httpx.AsyncClient. Fix the
+stale docstring.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] CSRF middleware blocks the localhost /admin/* operator endpoints
+
+```
+Summary
+The documented localhost CLI back-channel (/admin/*) is 403'd by the app-wide CSRF middleware
+before it ever reaches its own localhost auth, so the entire admin surface is unusable via its
+intended caller.
+
+Location
+bridge/csrf.py:33,69-70,83; bridge.py:800-924
+
+Details
+CSRFMiddleware exempts only ('/api/', '/metrics', '/health'). The /admin router (kid-mode,
+smart-mode, state, persona, safety) is not exempt and a curl/script call carries no CSRF cookie,
+so it is rejected before _admin_require_localhost runs.
+
+Proposed fix
+Add '/admin/' to _EXEMPT_PREFIXES in bridge/csrf.py (the /admin router already has its own
+localhost-only auth, the correct machine-to-machine model).
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] SSE /events served under BaseHTTPMiddleware (CSRF) — Starlette buffering hazard
+
+```
+Summary
+The text/event-stream response is wrapped by BaseHTTPMiddleware (CSRF), a documented Starlette
+SSE footgun that buffers chunks and breaks disconnect detection.
+
+Location
+bridge/dashboard.py:2091-2133; bridge/csrf.py:73-98
+
+Details
+CSRFMiddleware subclasses starlette.middleware.base.BaseHTTPMiddleware, which consumes the
+StreamingResponse through an anyio memory stream and can delay/not-flush chunks, defeating the
+X-Accel-Buffering: no header. Today only heartbeats flow, but the channel is structurally
+degraded once a producer is wired back.
+
+Proposed fix
+Exempt the SSE path from BaseHTTPMiddleware-style wrapping, or migrate CSRFMiddleware to a raw
+ASGI middleware so streaming responses pass through untouched.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] Kid/smart-mode toggles report ok:False while having already persisted+applied the flip
+
+```
+Summary
+When the firmware doesn't ack a toggle, the endpoint returns ok:False even though the bridge has
+already flipped and persisted the bit, so the operator sees "failed", re-toggles, and the state
+ping-pongs out of sync.
+
+Location
+bridge.py:630-643 (_dashboard_set_kid_mode); 695-707 (_dashboard_set_smart_mode)
+
+Details
+_dashboard_set_kid_mode persists + applies first, then dispatches the firmware set_toggle; if the
+device is asleep / WiFi drops, _dispatch_set_toggle returns False and the function returns
+{ok:False} even though the bridge state is already flipped. The UI can't distinguish "fully
+applied" from "not applied".
+
+Proposed fix
+Return ok:True with a separate device_pushed:false / warning field when the bridge write
+succeeded but only the firmware LED push failed (mirror the /admin/kid-mode shape). Render the
+persisted new_state and surface the firmware-ack failure as a non-fatal note.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] network_mode: host binds dashboard + /metrics to 0.0.0.0 with auth unset by default
+
+```
+Summary
+The shipped bridge compose runs host networking with no dashboard auth and no CSRF secret set, so
+the full mutation surface and /metrics are reachable unauthenticated from the whole LAN.
+
+Location
+bridge/docker-compose.yml:31,41-60; bridge.py:936; bridge/dashboard.py:259-267
+
+Details
+DOTTY_DASHBOARD_USER/PASS, DOTTY_CSRF_SECRET, and DOTTY_BRIDGE_HOST are all unset; auth is opt-in
+(_verify_dashboard_auth returns immediately when either env var is empty); DOTTY_BRIDGE_HOST
+defaults to 0.0.0.0. CSRF alone does not authenticate. An unauthenticated kid-mode-off toggle is
+reachable from the LAN.
+
+Proposed fix
+Ship the compose with DOTTY_DASHBOARD_USER/PASS + a persistent DOTTY_CSRF_SECRET from .env, and/or
+bind 127.0.0.1 by default with a documented reverse proxy. At minimum document the required auth env.
+
+Suggested labels: security, area:dashboard
+```
+
+---
+
+## [MEDIUM] Async dashboard routes read + JSON-parse the entire daily convo log synchronously
+
+```
+Summary
+status_strip / host_detail / alerts_count / alerts_detail read the whole convo-*.ndjson and
+json.loads every line on the loop thread, blocking all concurrent requests on each ~10s poll.
+
+Location
+bridge/dashboard.py:377-398,472-514,517-555,1631-1648
+
+Details
+_stackchan_last_seen does path.read_bytes() + per-line json.loads with no to_thread; alerts_count
+and alerts_detail do read_bytes().splitlines() + per-line json.loads inline. The log grows all day
+and is polled per open tab.
+
+Proposed fix
+Wrap the read+parse bodies in await asyncio.to_thread(...). Optionally tail the file rather than
+parsing the whole day.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [MEDIUM] Dashboard /actions/say and /actions/start-story bypass the kid-mode content filter
+
+```
+Summary
+The dashboard say/start-story ingresses hand text straight to inject-text with no content
+filtering, a second unfiltered speech path that isn't acknowledged in the kid-safety surface.
+
+Location
+bridge/dashboard.py:706-729,732-773
+
+Details
+say() and start_story() sanitise control chars and length, then call _inject_or_error without
+content_filter() (imported via bridge.text). When DOTTY_DASHBOARD_USER/PASS are unset (default),
+any LAN client can make Dotty speak arbitrary unfiltered text; these turns also never populate
+the _cf_recent ring powering /ui/safety/recent.
+
+Proposed fix
+Run the sanitised text through content_filter() when kid-mode is on (use kid_mode_getter),
+returning the safe replacement / a rejection and recording the hit.
+
+Suggested labels: bug, safety, area:dashboard
+```
+
+---
+
+## [MEDIUM] face_detected during talk state silently drops the bridge perception relay
+
+```
+Summary
+face_detected/face_lost transitions received while current_state == 'talk' are never forwarded to
+dotty-behaviour, desyncing consumers (greeter state, face_lost_aborter) for the whole conversation.
+
+Location
+custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:134-138
+
+Details
+The face_detected branch does `if cstate == 'talk': ... return`, which exits handle() entirely so
+the relay POST at lines 167-193 never runs. The talk-gate's intent is only to suppress
+re-triggering room_view capture, not forwarding the event.
+
+Proposed fix
+Replace the return with control flow that skips only the capture kick-off but still falls through
+to the relay (wrap the capture-start in `if cstate != 'talk':`).
+
+Suggested labels: bug, area:xiaozhi, area:behaviour
+```
+
+---
+
+## [MEDIUM] face_lost does not reset _room_description_in_flight, can wedge room_view capture
+
+```
+Summary
+A leaked _room_description_in_flight flag makes every subsequent face_detected refuse to re-capture
+for the life of the connection.
+
+Location
+custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:92-102,139-141
+
+Details
+face_detected gates capture on `not _room_description_in_flight`. face_lost clears the other
+room-view caches but never clears _room_description_in_flight, so a capture that crashed without
+resetting the flag wedges all future captures.
+
+Proposed fix
+In the face_lost branch also set conn._room_description_in_flight = False so a lost-then-reacquired
+face always re-arms a capture.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] WebSocket query-param device-id can bypass token auth via the allowlist short-circuit
+
+```
+Summary
+A client can put ?device-id=<an-allowed-device> in the URL and skip token verification, because
+query-param identity is injected into request.headers and trusted by the allowlist bypass.
+
+Location
+custom-providers/xiaozhi-patches/websocket_server.py:84-108,216
+
+Details
+_handle_connection injects device-id/client-id/authorization from query params into
+request.headers; _handle_auth reads them back and the allowed_devices whitelist short-circuit
+treats a query-param device-id the same as a header one. Headers mutation semantics are also
+version-fragile (__setitem__ may append).
+
+Proposed fix
+Treat query-param identity as untrusted: do not let a query-string device-id satisfy the
+allowlist bypass; require the token path for query-param connections. Use a separate dict for
+derived identity rather than mutating request.headers.
+
+Suggested labels: security, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] OTA _is_higher_version treats pre-release/build-suffix versions as numerically higher
+
+```
+Summary
+A release-candidate or build-tagged version is seen as HIGHER than its GA, so a device on GA is
+offered a stale rc and a device on the rc never sees the GA as newer.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:24-43,315 (also 314-332,94)
+
+Details
+_parse_version does re.findall(r'\d+', ver), so '1.2.3-rc1' -> (1,2,3,1) compares greater than
+'1.2.3' -> (1,2,3); '1.2' equals '1.2.0'. Build suffixes ('1.3.2 (build 47)') invert ordering.
+Verified: _is_higher_version('1.2.3-rc1','1.2.3') returns True. Drives both the candidate sort
+and the update decision.
+
+Proposed fix
+Use a real semver-ish comparator (strip leading v, parse the numeric core, rank pre-release
+suffixes BELOW the release, consider only the first 3 segments and ignore build metadata).
+Add unit tests for rc/build-suffix cases; add the module to coverage + a ci.yml test dir.
+
+Suggested labels: bug, area:xiaozhi, area:firmware
+```
+
+---
+
+## [MEDIUM] play-asset clobbers conn.client_abort / client_is_speaking, corrupting a concurrent voice turn
+
+```
+Summary
+A timer-driven play-asset landing mid-turn cancels a user's barge-in and marks the device idle
+while chat TTS is still streaming, desyncing the speaking-state machine.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:452-453,474
+
+Details
+_dispatch() unconditionally sets conn.client_abort=False then conn.client_is_speaking=True, and in
+finally sets client_is_speaking=False. play-asset is fire-and-forget on a ~20s security timer with
+non-deterministic device selection, with no guard that the conn is idle.
+
+Proposed fix
+Bail (or queue) if the conn is mid-turn — check client_is_speaking / an in-progress sentence_id
+and refuse with 409 if busy. Save/restore prior flags rather than hard-setting, or route admin
+audio through the TTS-priority queue.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] Admin handlers call conn.websocket.send() concurrently with the active chat-path writer
+
+```
+Summary
+Fire-and-forget admin sends run concurrently with xiaozhi's own send on the same WS connection;
+the websockets library forbids interleaved sends, so the command silently fails or a chat frame
+gets corrupted.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:146,194,242,288,338,456-468
+
+Details
+Every admin handler and play-asset write directly to conn.websocket.send() via _spawn(). A send
+from an admin task while the chat task is mid-send can raise ConcurrencyError (swallowed by the
+task done-callback) or interleave frames. play-asset (hundreds of opus frames) maximizes overlap.
+
+Proposed fix
+Serialize all device-bound writes through a single per-conn asyncio.Lock that admin handlers
+acquire. At minimum log the ConcurrencyError rather than dropping it, and gate audio pushes behind
+an idle check.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] _dotty_say mutates conn.sentence_id from a worker thread, racing the consumer and pre-empting chat TTS
+
+```
+Summary
+A /say landing mid-turn overwrites conn.sentence_id, causing the consumer to drop the chat turn's
+remaining sentences — truncating Dotty mid-sentence — and is a data race against the consumer thread.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:547-574,582
+
+Details
+_enqueue runs on a thread (asyncio.to_thread) and sets conn.sentence_id with no busy-check or lock
+before enqueueing FIRST/MIDDLE/LAST. The greeter fires on perception events that can coincide with
+a live conversation. There is also no tts_text_queue guard (AttributeError swallowed → silent no-op).
+
+Proposed fix
+Refuse /say with 409 when the conn is mid-turn; or push the greeting through the queue without
+overwriting sentence_id. Guard for tts_text_queue and 503 if absent. If sentence_id must be set, do
+it on the loop thread.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] play-asset omits the tts 'start' lifecycle frame and uses an unvalidated Opus rate
+
+```
+Summary
+Playback never sends the {type:tts,state:start} frame (firmware-fragile) and feeds conn.sample_rate
+straight into the Opus encoder without checking it is a legal rate; a bad rate silently returns 200.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:414,421-423,456-461
+
+Details
+The playback only emits sentence_start then opus frames then stop. tgt = conn.sample_rate is passed
+to OpusEncoderUtils; Opus only supports 8/12/16/24/48 kHz, so a non-legal rate raises inside _decode,
+is caught by the broad except (logs "decode failed"), and the endpoint still returns 200 ok.
+
+Proposed fix
+Emit the full lifecycle (start -> sentence_start -> frames -> stop). Validate tgt against
+{8000,12000,16000,24000,48000} (reject or resample). Propagate decode failure as 500 instead of 200.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] EventTextMessageHandler relays perception events to a stale BRIDGE_URL
+
+```
+Summary
+Perception events are POSTed to {BRIDGE_URL or VISION_BRIDGE_URL}/api/perception/event, but the bus
+moved to dotty-behaviour:8090 in #115; if the deploy sets the wrong var, every event 404s and is
+dropped, silently disabling face_greeter/sound_turner/state gating.
+
+Location
+custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:67-78,178
+
+Details
+The env var names and warning text still say BRIDGE_URL/VISION_BRIDGE_URL. If BRIDGE_URL points at
+the dashboard container (which no longer serves /api/perception/event), the relay 404s.
+
+Proposed fix
+Rename/select the env var to point at dotty-behaviour explicitly (e.g. BEHAVIOUR_URL) and update the
+warning string; or document that BRIDGE_URL must resolve to dotty-behaviour:8090. Verify the deploy
+compose sets the var the handler reads.
+
+Suggested labels: bug, area:xiaozhi, area:behaviour
+```
+
+---
+
+## [MEDIUM] state_changed/face_detected ordering can corrupt the room_view gate
+
+```
+Summary
+If the firmware emits face_detected before the IDLE->TALK state_changed it acted on, the room_view
+gate sees 'idle' and fires a capture for a mid-talk flicker — the stacked "Hi NAME" failure the
+comment claims to prevent.
+
+Location
+custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:109-115,133-138
+
+Details
+conn.current_state is set from state_changed and read on face_detected. The gate relies on
+state_changed always preceding the talk-phase face_detected, which the firmware does not guarantee.
+
+Proposed fix
+Gate on a positive "room_view already captured this session" flag (only capture if
+conn._room_description is None and no capture since last face_lost) rather than current_state. Or
+have firmware stamp face_detected with its state.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] Turn timeout is a fixed wall-clock deadline that ignores streaming progress
+
+```
+Summary
+A healthy but slow reply (think_hard escalation, 6-sentence story) is killed mid-stream because the
+turn deadline is set once and never extended while text streams.
+
+Location
+custom-providers/pi_voice/pi_client.py:220-269
+
+Details
+iter_turn_text sets deadline = time.time() + self._turn_timeout_sec (default 120s) before the loop
+and never resets it. The user hears a partial reply then the "(brain offline)" fallback. The timeout
+should bound silence/stall, not total length.
+
+Proposed fix
+Reset deadline = time.time() + self._turn_timeout_sec each time a text_delta (or any progress frame)
+is yielded, so the cap only fires when pi goes quiet.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] new_session failure proceeds with un-reset pi session, leaking prior-turn context
+
+```
+Summary
+When new_session fails, the next voice turn runs against pi's previous, non-reset session, carrying
+prior content (or a partially-absorbed jailbreak) into the next, possibly child, interaction.
+
+Location
+custom-providers/pi_voice/pi_voice.py:136-141
+
+Details
+response() calls self._client.new_session() but on PiClientError only logs and continues, and sets
+self._first_turn = False unconditionally — so a failed/timed-out reset is treated as a successful
+fresh turn.
+
+Proposed fix
+On new_session failure force a hard reset before proceeding (close + respawn the pi process), or
+surface the failure to the caller. Do not treat a failed reset as a fresh turn.
+
+Suggested labels: bug, safety, area:voice
+```
+
+---
+
+## [MEDIUM] _closed flag never reset after close() + reuse, suppressing reader-thread crash logging
+
+```
+Summary
+After a close() + reuse, a genuine reader-thread crash is silently swallowed, so turns just time out
+with no diagnostic trail.
+
+Location
+custom-providers/pi_voice/pi_client.py:171-182,311-313,352-354
+
+Details
+close() sets self._closed = True; _ensure_started() respawns the process and starts fresh reader
+threads but never resets _closed to False. The stdout/stderr exception handlers guard
+logger.exception with `if not self._closed:`, so with _closed stuck True real crashes are hidden.
+
+Proposed fix
+Reset self._closed = False inside _ensure_started() on (re)spawn; better, scope the "expected
+shutdown" suppression to the specific process generation rather than a sticky boolean.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] Abandoned iter_turn_text leaves pi streaming; a stale agent_end can terminate the next turn
+
+```
+Summary
+After a barge-in/abort, the following voice turn can come back empty or with stale text because an
+abandoned turn's trailing agent_end (not id-matched) terminates the next turn.
+
+Location
+custom-providers/pi_voice/pi_client.py:211-269 (also 188-209)
+
+Details
+iter_turn_text sends a prompt then yields deltas until agent_end. On early stop (face_lost_aborter
+abort, barge-in) the generator is GC'd without consuming agent_end; pi keeps generating and queues
+frames. new_session may race the in-flight turn, and a leftover agent_end satisfies the NEXT
+iter_turn_text's terminator (agent_end is matched on type, not req_id).
+
+Proposed fix
+Send an explicit cancel/abort to pi when a turn generator is abandoned (try/finally inside
+iter_turn_text). Drain-and-discard the prior turn's frames keyed by the abandoned req_id before the
+next prompt. Tag agent_end matching with req_id. Have new_session() block until the prior turn's
+agent_end (or a hard reset).
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] OpenAICompat can emit two emojis when a valid emoji is not at the start
+
+```
+Summary
+When the model's reply contains a valid emoji but not as the first character, the code prepends the
+fallback emoji AND yields the original content with its embedded emoji — two emojis, violating the
+single-emoji HARD CONSTRAINT.
+
+Location
+custom-providers/openai_compat/openai_compat.py:218-229
+
+Details
+Enforcement only checks so_far.startswith(emoji). For "Well, 😊 hi there", so_far starts with 'W',
+so it prepends 😐 and then yields content still containing 😊. Firmware keys the face on the first
+emoji; the second garbles TTS. The check latches after the first content, never stripping embedded emojis.
+
+Proposed fix
+After deciding the leading content lacks a valid emoji prefix, strip embedded emojis from the
+streamed body before yielding (reuse textUtils.check_emoji/is_emoji). A robust fix buffers until the
+first non-whitespace char, decides the prefix, then filters subsequent emojis.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] OpenAICompat speaks chain-of-thought when pointed at a reasoning model
+
+```
+Summary
+OpenAICompat has no thinking filter, so an inline-<think> reasoning model has Dotty narrate its
+reasoning aloud, and the leading < defeats the emoji-prefix check.
+
+Location
+custom-providers/openai_compat/openai_compat.py:189-229
+
+Details
+PiClient filters thinking_delta; OpenAICompat reads only choices[0].delta.content and yields it
+verbatim. The local backend serves qwen3.6 reasoning models that emit <think>...</think> inline
+(spoken to TTS) or in delta.reasoning_content (dropped, but the visible answer arrives after a long
+silent gap, tripping the turn timeout).
+
+Proposed fix
+Strip <think>...</think> spans from content before the emoji check/yield (stateful across chunks),
+and ignore delta.reasoning_content. Or send a param to disable thinking. Guard against a leading <
+defeating the emoji-prefix enforcement.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] OpenAICompat appends the safety/format suffix to the wrong message when no user turn exists
+
+```
+Summary
+If the final dialogue turn is a system/assistant/tool message, the HARD CONSTRAINTS suffix
+(emoji rule, English-only, length, kid-mode filter) is never injected and the model runs unconstrained.
+
+Location
+custom-providers/openai_compat/openai_compat.py:101-114
+
+Details
+_build_messages computes last_user_idx and appends _TURN_SUFFIX only there; if last_user_idx is None
+(no user role — proactive greeter injections, tool/function turns), the suffix is never added.
+pi_voice avoids this by only sending the last user text; OpenAICompat forwards the whole dialogue.
+
+Proposed fix
+If last_user_idx is None, append _TURN_SUFFIX to a synthesized trailing user message (or to the last
+message regardless of role) so the safety/format constraints are always present.
+
+Suggested labels: bug, safety, area:voice
+```
+
+---
+
+## [MEDIUM] OpenAICompat yields whitespace-only content chunks to TTS before emoji enforcement
+
+```
+Summary
+A whitespace-only first chunk is yielded to TTS before the emoji-prefix enforcement engages, so the
+first thing TTS/firmware sees is whitespace rather than the emoji the contract promises.
+
+Location
+custom-providers/openai_compat/openai_compat.py:216-229
+
+Details
+Every non-empty content delta is yielded at :229 unconditionally; enforcement only fires once
+so_far = ''.join(full_text).lstrip() is non-empty. Leading whitespace deltas (common with reasoning
+models / templated outputs) go out before any emoji; an all-whitespace stream fires the fallback
+after whitespace already went to TTS.
+
+Proposed fix
+Buffer content until so_far (lstripped) is non-empty before yielding anything; do not yield raw
+whitespace-only deltas. Yield the (optionally emoji-prefixed) accumulated buffer once real content
+exists.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [MEDIUM] processed_chars over-count in edge_stream and piper_local
+
+```
+Summary
+After synthesizing the remaining tail, processed_chars is advanced by len(full_text) on top of an
+already-nonzero absolute index, overshooting; a re-entered LAST silently drops the final sentence's audio.
+
+Location
+custom-providers/edge_stream/edge_stream.py:67-74
+custom-providers/piper_local/piper_local.py:114-121
+
+Details
+remaining_text = full_text[self.processed_chars:] (absolute index), then
+self.processed_chars += len(full_text). Post-condition should be processed_chars == len(full_text).
+Masked by the per-turn FIRST reset, but a LAST without an intervening FIRST drops the tail.
+
+Proposed fix
+self.processed_chars = len(full_text) (or += len(remaining_text)) in both files. Consider hoisting
+the duplicated method into a shared mixin. Add the packages to coverage + a unit test.
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [MEDIUM] fun_local crashes in __init__ when output_dir is unset
+
+```
+Summary
+FunASR fails hard on a config that WhisperLocal tolerates, because os.makedirs(None) raises TypeError.
+
+Location
+custom-providers/asr/fun_local.py:51-58
+
+Details
+self.output_dir = config.get("output_dir") returns None when absent, then
+os.makedirs(self.output_dir, exist_ok=True) is called unconditionally. whisper_local.py:48 guards
+with `if self.output_dir:`; fun_local does not.
+
+Proposed fix
+Guard the call: `if self.output_dir: os.makedirs(self.output_dir, exist_ok=True)`.
+
+Suggested labels: bug, area:asr
+```
+
+---
+
+## [MEDIUM] ASR model invoked from worker threads with no lock — not thread-safe under concurrent transcription
+
+```
+Summary
+faster-whisper / FunASR are not safe for concurrent calls on the same model object; two overlapping
+sessions can corrupt output or segfault the container.
+
+Location
+custom-providers/asr/whisper_local.py:107-109,161-173
+custom-providers/asr/fun_local.py:81-88 (mirror)
+
+Details
+speech_to_text offloads inference via asyncio.to_thread on a singleton model shared across
+connections; to_thread schedules concurrent calls on separate threads racing the underlying
+CTranslate2 / FunASR C++ state.
+
+Proposed fix
+Serialize inference with a per-instance threading.Lock held inside _transcribe_blocking / around
+model.generate. Negligible latency for the single-device case, prevents the concurrent crash.
+
+Suggested labels: bug, area:asr
+```
+
+---
+
+## [MEDIUM] before_stop play files dropped when the final segment's synthesis fails
+
+```
+Summary
+A LAST-segment synth failure abandons any queued before_stop_play_files (e.g. a play_song trailing
+asset) — they are neither played nor cleared, and can leak into the next utterance.
+
+Location
+custom-providers/edge_stream/edge_stream.py:139-143
+custom-providers/piper_local/piper_local.py:187-191 (mirror)
+
+Details
+The normal path calls _process_before_stop_play_files() when is_last; the except handler never does.
+
+Proposed fix
+In the except handler, when is_last is True, still call self._process_before_stop_play_files() (and
+clear the list) so trailing assets are honored or cleaned up.
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [MEDIUM] SentenceType.FIRST audio marker is emitted once per segment instead of once per reply
+
+```
+Summary
+A multi-segment reply pushes multiple FIRST markers, which downstream treats as start-of-response
+and can re-trigger the talk animation / state mid-sentence.
+
+Location
+custom-providers/edge_stream/edge_stream.py:101
+custom-providers/piper_local/piper_local.py:146 (mirror)
+
+Details
+text_to_speak unconditionally puts (SentenceType.FIRST, [], text) at the top of every call; each
+segment is a separate text_to_speak call.
+
+Proposed fix
+Gate FIRST so it is emitted only for the first segment of a reply (track a per-reply
+first_segment_sent flag, otherwise emit a continuation/MIDDLE marker).
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [MEDIUM] Face recognizer reads the camera frame buffer after releasing the arbiter (latent UAF)
+
+```
+Summary
+processFrame() releases the detection arbiter, then still uses the raw V4L2 frame pointer; once the
+ESP-DL embedding crop is wired in, this becomes a live use-after-free / torn-frame read across the
+two camera tasks.
+
+Location
+firmware/firmware/main/stackchan/face/face_detector.cpp:236-292
+
+Details
+arbiter.releaseForDetection() at :236, but frame_data (captured at :183) is stored into face_img.data
+(:277) and passed to recognize() (:292). After release, acquireForCapture()/StreamCaptures() can
+dequeue/requeue the V4L2 buffer and overwrite the memory frame_data points into.
+
+Proposed fix
+Hold the detection lock across recognize() (move releaseForDetection() after the recognition block),
+OR copy the bounded face crop into a heap buffer while still holding the arbiter and point
+face_img.data at the copy. Never pass a driver-owned frame pointer to a consumer that runs after release.
+
+Suggested labels: bug, area:firmware, safety
+```
+
+---
+
+## [MEDIUM] SoundLocalizer high-pass filter state goes stale during cooldown, firing spurious direction changes
+
+```
+Summary
+The HPF state freezes during the 750ms cooldown, so the first post-cooldown frame injects a large
+artificial transient that can push energy past threshold and fire a spurious sound_event direction change.
+
+Location
+firmware/firmware/main/stackchan/sound_localizer.cpp:19-23,44-51
+
+Details
+OnStereoFrame() returns early on the cooldown gate BEFORE the per-sample loop that advances
+_hp_*_prev_x/_hp_*_prev_y. The first frame after cooldown evaluates x[n] - x[n-1] across the 750ms
+discontinuity.
+
+Proposed fix
+Advance the HPF state on every frame regardless of the gates (move the filter loop above the cooldown
+return, keeping only the emit gated), or seed _hp_*_prev_x to the new frame's first sample so the next
+post-cooldown frame doesn't see a step.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [MEDIUM] ImuEventModifier steals and releases the shared modify-lock it may not own
+
+```
+Summary
+A shake during a photo releases Capture()'s modify-lock while the photo is in progress, letting the
+head move during capture and corrupting the still.
+
+Location
+firmware/firmware/main/stackchan/modifiers/imu.h:58-61,117,79,105
+
+Details
+IMU sets the motion lock only if not held (lines 58-61), but restore_state() ALWAYS clears it (117).
+If Capture() already holds the lock when a shake arrives, IMU skips re-locking but its restore
+releases Capture's lock. The avatar lock has the same shape.
+
+Proposed fix
+Give the modify-lock real ownership (refcount/owner-token), or have IMU remember whether it actually
+acquired the lock (bool _took_motion_lock) and only release in restore_state() if it took it.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [MEDIUM] FaceDetector::stop() frees buffer and deletes the stop-semaphore without checking the take succeeded
+
+```
+Summary
+If the detector task overruns the 2s stop timeout, stop() deletes the semaphore and frees the buffer
+the still-running task owns — a use-after-free of both.
+
+Location
+firmware/firmware/main/stackchan/face/face_detector.cpp:100-117
+
+Details
+stop() does xSemaphoreTake(_stop_sem, 2000ms) WITHOUT checking the return, then unconditionally nulls
+_task_handle, vSemaphoreDelete(_stop_sem), and heap_caps_free(_rgb_buffer). The live task then gives a
+deleted semaphore and uses freed state. Currently unwired (only start()/setEnabled() are used).
+
+Proposed fix
+Capture the take result; only delete the semaphore / free the buffer / null the handle when it
+returned pdTRUE. On timeout, log and leak (or loop with a longer bound) rather than tearing down
+resources the live task still owns.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [MEDIUM] startToChat: missing "language" key throws KeyError and feeds raw JSON to the pipeline
+
+```
+Summary
+For a voiceprint payload lacking a language field, the speaker-extraction silently fails and the raw
+JSON envelope is run through ASR corrections / intent detection / the LLM.
+
+Location
+receiveAudioHandle.py:1057-1063
+
+Details
+The speaker block does _language_tag = data["language"] (subscript) inside a try with
+`except (json.JSONDecodeError, KeyError): pass`. When speaker+content are present but language is
+absent, line 1059 raises KeyError before actual_text is assigned, so actual_text stays the raw JSON
+string and current_speaker is never set.
+
+Proposed fix
+Use _language_tag = data.get("language") so a missing language key is tolerated; only speaker/content
+should be required (already gated by the `in` checks).
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [MEDIUM] provision.py: read-only permission overwrites never re-applied to existing channels
+
+```
+Summary
+The script isn't idempotent for permissions: a READ_ONLY channel that already exists keeps
+@everyone send_messages, with the script reporting "= #... (exists)".
+
+Location
+community/discord/provision.py:197-202
+
+Details
+The existing-channel branch only fixes the category, then continues — it never calls overwrites_for()
+or applies overwrites. So missing/incorrect permission overwrites are never reconciled, a
+security-relevant gap for a public community server.
+
+Proposed fix
+In the existing branch, compute ov = overwrites_for(...) and, when non-empty, await
+existing.edit(overwrites=ov) so permissions converge on every run.
+
+Suggested labels: bug, area:community
+```
+
+---
+
+## [MEDIUM] dotty_doctor check_http treats 404 (and all <500) as pass for the OTA endpoint
+
+```
+Summary
+A 404 on /xiaozhi/ota/ — exactly the misconfiguration the doctor exists to catch — is reported as PASS.
+
+Location
+scripts/dotty_doctor.py:166-168
+
+Details
+check_http returns 'pass' for any HTTP status < 500. The OTA path returning 404 (route wrong/missing,
+or server up but not serving OTA) passes silently.
+
+Proposed fix
+Treat 2xx (and arguably 3xx) as pass; flag 4xx as warn/fail with the status code in the detail.
+
+Suggested labels: bug, area:tooling
+```
+
+---
+
+## [MEDIUM] MCP JSON-RPC request ids collide for calls in the same millisecond
+
+```
+Summary
+Two MCP calls dispatched within the same millisecond get identical JSON-RPC ids; any relay that
+correlates responses by id will mismatch or drop the colliding pair.
+
+Location
+receiveAudioHandle.py:281,319,349,373,399,456,559
+
+Details
+Every outbound MCP call computes id = int(time.time()*1000) % 0x7FFFFFFF. This happens routinely:
+_sync_toggles_once fires set_toggle(kid_mode) then set_toggle(smart_mode) back-to-back, and
+execute_choreography sends a HEAD and a LED at the same t_ms timeline mark.
+
+Proposed fix
+Use a monotonic per-connection counter (itertools.count / conn._mcp_id) via a shared
+_next_mcp_id(conn) helper, fixing all seven sites at once.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] dotty_doctor passes Piper without the required .onnx.json config pair
+
+```
+Summary
+A missing/stub .onnx.json (the exact corrupt-download failure the SenseVoice check was hardened
+against) still reports a green PASS while the TTS provider crashes at runtime.
+
+Location
+scripts/dotty_doctor.py:146-155
+
+Details
+check_models_piper only globs *.onnx; Piper requires a companion <model>.onnx.json. The glob *.onnx
+does not match *.onnx.json, so the config is never inspected.
+
+Proposed fix
+For each *.onnx found, assert the sibling *.onnx.json exists above a sane byte floor (~200 B),
+mirroring the SenseVoice size-floor approach.
+
+Suggested labels: bug, area:tooling
+```
+
+---
+
+## [LOW] render_singing_sinsy crashes with ZeroDivisionError on empty/all-comment lyrics
+
+```
+Summary
+A lyrics file that is empty or comments-only crashes build_singing_score with an opaque
+ZeroDivisionError instead of a clean error.
+
+Location
+scripts/render_singing_sinsy.py:89 (reachable via load_lyrics 48-61)
+
+Details
+load_lyrics skips blank/comment lines and can return []. build_singing_score guards the note list but
+not the syllable list; line 89 does syllables[i % len(syllables)] with len==0.
+
+Proposed fix
+After load_lyrics in main() (or at the top of build_singing_score), add a guard:
+if not syllables: print error; return 1. Mirror the existing 'has no notes' guard.
+
+Suggested labels: bug, area:tooling
+```
+
+---
+
+## [LOW] _send_led_color swallows all exceptions silently
+
+```
+Summary
+A broken WS during a dance silently no-ops every LED update with no log, making "dance ran but no
+lights" undebuggable.
+
+Location
+receiveAudioHandle.py:285-286
+
+Details
+_send_led_color wraps the websocket.send in a bare `except Exception: pass` with no logging, unlike
+_send_led_multi which warns-once.
+
+Proposed fix
+Log the exception (warn-once, matching _send_led_multi's pattern) rather than a silent pass.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] _encode_midi_to_opus forces ALL set_tempo events to one value
+
+```
+Summary
+Songs whose MIDI encodes legitimate mid-piece tempo changes are flattened to a single constant
+tempo, breaking duration/beat alignment for any such file.
+
+Location
+receiveAudioHandle.py:850-857
+
+Details
+When target_tempo_bpm is set, the loop rewrites every set_tempo in every track to new_tempo. Benign
+for the current .mid registry, latent for any added song with tempo automation.
+
+Proposed fix
+Rewrite only the first/global tempo, or scale all tempos by the same ratio relative to the original
+first tempo.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] _handle_dance: singing stream task untracked, so a new utterance cancels choreography but not the audio
+
+```
+Summary
+On barge-in the choreography is cancelled but the singing audio keeps streaming Opus to the device,
+relying entirely on the abort flag being set synchronously.
+
+Location
+receiveAudioHandle.py:789-802,1092-1096
+
+Details
+Choreography runs as conn._dance_task (tracked, cancelled on the next turn); the singing audio runs as
+a separate fire-and-forget asyncio.create_task whose handle is never stored on conn.
+
+Proposed fix
+Store conn._singing_task and cancel it alongside _dance_task on the new-utterance/abort path.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] Idle end-prompt re-enters the full intent pipeline via startToChat
+
+```
+Summary
+A customised idle end-prompt containing words like "dance"/"sleep"/a vision phrase fires that
+side-effect at the moment the connection is closing.
+
+Location
+receiveAudioHandle.py:1208-1211
+
+Details
+no_voice_close_connect feeds end_prompt.prompt through startToChat, which runs _detect_state_phrase /
+_is_vision_request / _is_dance_request. close_after_chat is already set, so the behaviour competes with
+shutdown.
+
+Proposed fix
+Submit the end-prompt directly to the LLM (_submit_chat / conn.chat) bypassing the intent pipeline, or
+add a flag to startToChat to skip state/dance/vision detection for system-originated prompts.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] provision.py create_forum drops the computed permission overwrites
+
+```
+Summary
+The FORUM branch omits overwrites=ov, silently no-opping a future read-only forum lockdown.
+
+Location
+community/discord/provision.py:204-213
+
+Details
+overwrites_for is computed for every new channel and the text branch passes overwrites=ov, but
+guild.create_forum(...) omits it. Benign today (no forum in READ_ONLY).
+
+Proposed fix
+Pass overwrites=ov to guild.create_forum(...), matching the text-channel branch.
+
+Suggested labels: bug, area:community
+```
+
+---
+
+## [LOW] /api/perception/state emits invalid JSON (Infinity) for devices with no last_event_t
+
+```
+Summary
+A device with no last_event_t serializes sensor_age_s as the bare token Infinity, which is not valid
+JSON and breaks strict parsers / the dashboard perception card.
+
+Location
+dotty-behaviour/perception/state.py:328-336 (reachable via routes/perception.py:73-85, routes/vision.py:188)
+
+Details
+_annotate sets age = float('inf') when last_event_t is absent; Starlette's JSONResponse serializes
+with allow_nan=True. Reachable for a known device that got a room_view capture but never sent a
+perception event, and unconditionally for any unknown device_id.
+
+Proposed fix
+Replace age = float('inf') with a JSON-safe value (None / -1) and rely on sensor_stale=True; add a
+regression test that the route body parses as standard JSON.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Failed/empty weather fetch arms the full 30-min TTL
+
+```
+Summary
+A transient weather failure marks the cache fresh for the full TTL, so no retry happens and prompts
+keep using stale (or empty) weather text.
+
+Location
+dotty-behaviour/calendar_/cache.py:124-127 (set_weather); driven by poll.py:46-48
+
+Details
+fetch_weather returns "" on any failure; set_weather only overwrites weather_text on truthy text but
+UNCONDITIONALLY bumps weather_fetched_perf, so ttl_expired stays false for the next full TTL window.
+
+Proposed fix
+Advance weather_fetched_perf only on a successful (non-empty) fetch (guard the bump behind `if text:`),
+or use a short retry interval on empty. Add a test asserting an empty fetch leaves the timestamp
+unchanged.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] No upload size limit on /api/vision/explain and /api/audio/explain (LAN OOM)
+
+```
+Summary
+Both endpoints read the entire multipart upload into memory (+ ~1.33x for base64) with no size cap,
+so a single large/malicious POST can exhaust container memory and take down the daemon.
+
+Location
+dotty-behaviour/routes/vision.py:145 (and audio.py:87)
+
+Details
+await file.read() reads the whole upload; no Content-Length cap, no streaming. Both endpoints bind
+0.0.0.0:8090. The JPEG is also retained per-device in vision_cache.
+
+Proposed fix
+Check Content-Length up front and reject >N (e.g. 5 MB JPEG, 10 MB audio) with 413, or read in
+bounded chunks. Apply to both endpoints.
+
+Suggested labels: bug, security, area:behaviour
+```
+
+---
+
+## [LOW] Consumer task crashes are silently swallowed (no log, no restart)
+
+```
+Summary
+A consumer's run() raising at runtime dies silently and the daemon keeps reporting "ready" while the
+consumer is dead.
+
+Location
+dotty-behaviour/main.py:325-341
+
+Details
+Consumers are launched with asyncio.create_task and only awaited at shutdown via
+gather(..., return_exceptions=True), which captures and discards exceptions. No done-callback surfaces
+them at failure time; no restart.
+
+Proposed fix
+Attach a done-callback that logs non-cancelled exceptions at failure time; optionally wrap each
+consumer in a supervising restart loop.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] vision_latest lost-wakeup race + unconditional fresh-capture eviction
+
+```
+Summary
+A concurrent explain that signals between the cache pop and waiter registration is missed (spurious
+404), and the unconditional pop discards a fresh capture another producer just wrote.
+
+Location
+dotty-behaviour/routes/vision.py:331-352,332
+
+Details
+vision_latest pops the cache, registers a waiter, then awaits the Event; signal_vision_waiters only
+set()s already-registered Events, so a signal in the pop→register window is lost and the waiter 404s
+at the 15s timeout. The pop has no freshness check, so it deletes a fresh idle-photographer/room_view
+entry (and its jpeg_bytes that /api/vision/photo serves).
+
+Proposed fix
+Make the wakeup level-triggered (re-check the cache after registering before awaiting, or use a
+generation counter). Pop only entries actually older than the TTL.
+
+Suggested labels: bug, area:behaviour, area:vision
+```
+
+---
+
+## [LOW] Failed room_view VLM call still arms the 120s cooldown
+
+```
+Summary
+A transient VLM blip arms the full 120s room_view cooldown despite never producing a usable
+description, disabling named greetings for minutes.
+
+Location
+dotty-behaviour/routes/vision.py:188-204
+
+Details
+last_room_view_capture_t is set BEFORE vlm.describe_image, which never raises (returns
+VLM_NETWORK_ERROR_SENTINEL / VLM_OFFLINE_SENTINEL on failure). So an unreachable VLM still records the
+timestamp and gates further captures for 120s.
+
+Proposed fix
+Set last_room_view_capture_t only after a successful, non-sentinel VLM response, or use a much shorter
+failure-cooldown.
+
+Suggested labels: bug, area:behaviour, area:vision
+```
+
+---
+
+## [LOW] VLM error/offline SENTINEL strings cached and leaked into the perception snapshot
+
+```
+Summary
+A single VLM outage poisons Dotty's voice prompt for up to 60s on subsequent turns by caching the
+loud-error sentinel as a real description.
+
+Location
+dotty-behaviour/routes/vision.py:195-242 (sentinels in dispatch/vlm.py:22-29)
+
+Details
+vision_explain stores VLM_OFFLINE_SENTINEL / VLM_NETWORK_ERROR_SENTINEL verbatim as
+vision_cache[device_id]["description"] with a fresh wall_ts. perception/snapshot.py:142-147 then
+surfaces it as `You see: ERROR: the vision service didn't respond...`, and the idle photographer can
+persist it to NDJSON.
+
+Proposed fix
+Detect the sentinel set after describe_image and skip the cache write + signal_vision_waiters on
+sentinel returns. Same guard for the audio fallback string.
+
+Suggested labels: bug, area:behaviour, area:vision
+```
+
+---
+
+## [LOW] perception/state limit query params unvalidated (negative/zero slice quirks)
+
+```
+Summary
+A client-supplied limit flows unbounded into list slices; limit=-3 drops the 3 newest events and
+balances[-0:] returns the FULL series.
+
+Location
+dotty-behaviour/routes/perception.py:88-99,124
+
+Details
+perception_recent forwards limit into items[:limit] (state.py:152) with no >=0 bound; sound_balance_series
+ends with balances[-limit:] where limit=0 returns the whole list.
+
+Proposed fix
+Clamp limit = max(0, min(limit, MAX)); special-case limit <= 0 (return []) before the balance slice.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Client-supplied event ts can be set in the future, defeating staleness gates
+
+```
+Summary
+A future ts makes age negative → clamped to 0, so get_fresh_face_id treats a stale identity as
+permanently fresh and staleness never trips. ESP32 RTCs are frequently unsynced.
+
+Location
+dotty-behaviour/routes/perception.py:61-68
+
+Details
+perception_event uses payload.ts verbatim. Downstream freshness logic computes age = now - last_t with
+max(0.0, ...) clamps or direct > ttl comparisons.
+
+Proposed fix
+Reject or clamp implausible future timestamps on ingest (substitute time.time() if >few seconds
+ahead). Guard get_fresh_face_id against negative age (treat as stale).
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] perception/state stale dance_active never cleared on a missed terminal event
+
+```
+Summary
+A dropped dance_ended/state_changed latches dance_active True indefinitely, permanently suppressing
+room_view captures and greetings for that device.
+
+Location
+dotty-behaviour/perception/state.py:185-199
+
+Details
+dance_active is set on dance_started / state_changed->dance and cleared only on a terminal event; the
+bus drops events on a full subscriber queue, so a lost terminal frame strands the flag. No time-based
+expiry.
+
+Proposed fix
+Make is_dance_active freshness-bounded against last_dance_started_t with a max-dance TTL.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Greeter day-GC discards other days' slots; midnight-roll cooldown corruption
+
+```
+Summary
+The greeter persists never more than one day of slots, and a perception event spanning midnight can
+slip a near-instant second greeting through.
+
+Location
+dotty-behaviour/greeter/greeter.py:224-228
+
+Details
+_take_slot derives today from wall-now but uses event_ts for cooldown; the GC collapses _state to
+{today: ...} (then _save_state persists the truncated dict). A pre-midnight event handled just after
+midnight is filed under the new day with old-day cooldown math.
+
+Proposed fix
+Key the day on event_ts; GC by dropping only days older than a retention window (keep today + yesterday).
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] SecurityCycle keeps capturing on a missed/early transition
+
+```
+Summary
+A dropped non-security state_changed leaves the per-device capture loop firing the camera forever, and
+a security session already live when the consumer subscribes never starts the timer.
+
+Location
+dotty-behaviour/consumers/security_cycle.py:238-257
+
+Details
+Capture is started/stopped purely off live state_changed events with no reconciliation against
+current_device_state.
+
+Proposed fix
+On subscribe, seed timers from current per-device current_state. Reconcile each running timer against
+current_device_state per cycle and self-cancel when no longer 'security'.
+
+Suggested labels: bug, area:behaviour, safety
+```
+
+---
+
+## [LOW] calendar fetch time window excludes the final minute of the day
+
+```
+Summary
+Late-evening events near midnight can be silently missing because timeMax is exclusive and set to 23:59:59.
+
+Location
+dotty-behaviour/calendar_/fetch.py:60-66
+
+Details
+time_max = now.replace(hour=23,minute=59,second=59,microsecond=0). The Calendar API timeMax is
+exclusive; the conventional correct bound is the start of the next local day.
+
+Proposed fix
+time_max = (start_of_today + timedelta(days=1)).isoformat().
+
+Suggested labels: bug, area:behaviour, area:calendar
+```
+
+---
+
+## [LOW] CalendarCache.flush_for_new_day produces a long empty-context window on day-roll fetch failure
+
+```
+Summary
+A failing day-roll refresh leaves a guaranteed-empty calendar and, with backoff, can show no events
+for up to 10 minutes in the morning even though yesterday's data was serviceable a moment earlier.
+
+Location
+dotty-behaviour/calendar_/cache.py:116-122 + poll.py:53-75
+
+Details
+refresh_if_stale eagerly flushes events then attempts the fetch; on failure the except only bumps
+calendar_failures, and _sleep_seconds escalates to up to 600s.
+
+Proposed fix
+Flush only on a successful fetch, or reset calendar_failures / use the base interval for the first
+retry after a day-roll flush.
+
+Suggested labels: bug, area:behaviour, area:calendar
+```
+
+---
+
+## [LOW] room_view 'no one in view' sentinel uses substring match
+
+```
+Summary
+A valid identification whose DESC merely mentions "no one in view" is discarded as an empty frame,
+throwing away both the description and the matched identity.
+
+Location
+dotty-behaviour/vision/room_view.py:152-153
+
+Details
+parse_room_view_response does `if ROOM_VIEW_NO_PERSON in cleaned.lower(): return None, None, None` — a
+substring test against the whole reply.
+
+Proposed fix
+Match the sentinel only when it is the entire reply (modulo whitespace/punctuation); try the DESC/NAME
+regex first and only fall back to the sentinel check on a format miss.
+
+Suggested labels: bug, area:behaviour, area:vision
+```
+
+---
+
+## [LOW] FaceIdentifiedRefresher keeps the green ID LED lit when identity came from room_view
+
+```
+Summary
+A room_view identity keeps the green identified pip lit for the full TTL even after the person walked
+off, because face_present is never set.
+
+Location
+dotty-behaviour/consumers/face_identified_refresher.py:65-71
+
+Details
+The skip gate `if not face_present and last_lost:` only suppresses when the face was both absent AND
+previously lost. A room_view identification sets last_face_id without face_present and without a
+face_lost, so the gate is never entered and the LED re-fires every interval.
+
+Proposed fix
+Treat "identity present but face_present False and never positively detected" as a stop condition
+(skip refresh when not face_present, or require a positive face_present before keeping the pip lit).
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] FaceGreeter consumes the greet cooldown even when suppressed by an active dance
+
+```
+Summary
+A face event during a dance silently burns the per-identity/per-device cooldown without greeting, so a
+person who arrives during a dance is denied their greeting both during the dance and for the full
+cooldown after.
+
+Location
+dotty-behaviour/consumers/face_greeter.py:148-168,105-126
+
+Details
+The cooldown slot is written BEFORE the is_dance_active gate in both _handle_face_recognized and
+_handle_face_detected. last_face_greet_t also arms face_lost_aborter.
+
+Proposed fix
+Move the is_dance_active (and empty-text / mic-only) checks ABOVE the cooldown-slot write in both
+handlers.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] last_chat_t is never written on real conversations — QUIET_AFTER_CHAT gates are dead
+
+```
+Summary
+The named-greet and sound-turner "don't fire while the user is mid-conversation" gates never fire,
+because nothing records actual conversation activity.
+
+Location
+dotty-behaviour/consumers/face_greeter.py:149-156 + sound_turner.py:77-79 + perception/state.py:200-203
+
+Details
+Both gates read dev_state['last_chat_t'], but the only writer is purr_player.py (which pokes it into
+the future). update_state handles chat_status by setting 'listening', not last_chat_t. Regression from
+bridge.py's /api/message ingress.
+
+Proposed fix
+Write last_chat_t on conversation activity (set it on a chat_status 'listening' event and/or the
+relayed user-utterance path), or drop the gates as inert.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] FaceLostAborter leaks completed abort tasks in _pending forever
+
+```
+Summary
+A completed abort task with no subsequent face event stays in _pending, so the dict never shrinks for
+departed devices.
+
+Location
+dotty-behaviour/consumers/face_lost_aborter.py:101-103,47-55
+
+Details
+_pending entries are only removed by a subsequent face_detected or a newer face_lost; a simple
+fire-and-complete leaves a done task in the dict.
+
+Proposed fix
+Add a done-callback that discards the entry (matching the _tasks.discard pattern other consumers use).
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Vision room_view block-reason early return skips stale-cache eviction
+
+```
+Summary
+On frequently-gated deployments, stale vision_cache entries for other devices are never reclaimed
+because the block-reason early return bypasses the eviction loop.
+
+Location
+dotty-behaviour/routes/vision.py:176-186
+
+Details
+A gated room_view request writes a fresh entry and returns at :186, before the stale-eviction loop at
+:273-279 that runs only on the normal path.
+
+Proposed fix
+Factor the stale-eviction loop into a helper and call it on every exit path, including the block-reason
+early return.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Blocking file I/O on the event loop in greeter state persistence
+
+```
+Summary
+Every successful greet stalls the single event loop on synchronous disk I/O.
+
+Location
+dotty-behaviour/greeter/greeter.py:246,420-435
+
+Details
+_take_slot calls _save_state() synchronously (mkdir, tmp.write_text, os.replace) from the bus event
+handler on the asyncio loop.
+
+Proposed fix
+await asyncio.to_thread(self._save_state) (the handler is already async), or batch/debounce persistence.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] SleepDreamer / DanceReflector dereference event.data without None-guard, crashing the consumer loop
+
+```
+Summary
+A state_changed/dance_ended frame with data=None raises AttributeError caught only by the OUTER
+try/except, which logs "crashed" and EXITS the consumer permanently.
+
+Location
+dotty-behaviour/consumers/sleep_dreamer.py:166-168; dance_reflector.py:89-92
+
+Details
+Both do `.get` directly on event.data; sibling consumers use `(event.data or {})`. The except is
+outside the while loop, so one bad frame kills the consumer for the process lifetime.
+
+Proposed fix
+Use (event.data or {}).get(...); wrap per-event handling so a single bad frame doesn't terminate the
+loop. Consider giving PerceptionEvent.data a default_factory=dict.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] HouseholdRegistry.get_by_calendar_prefix only matches with bracketed YAML
+
+```
+Summary
+A household member whose calendar_prefix is configured without brackets is unreachable by
+get_by_calendar_prefix.
+
+Location
+dotty-behaviour/household/registry.py:190-200 vs 293-294
+
+Details
+_reload indexes by_prefix[person.calendar_prefix.strip().lower()] verbatim, but get_by_calendar_prefix
+bracket-normalizes the query (`if not key.startswith('['): key = f'[{key}]'`). The two agree only when
+the YAML value already has brackets. (No non-test callers today, so latent.)
+
+Proposed fix
+Normalize both sides identically (bracket-normalize calendar_prefix when building by_prefix, or strip
+brackets on both). Add a test for both YAML forms.
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Person.days_until_birthday shifts Feb-29 birthdays to Feb-28, firing the greeting a day early
+
+```
+Summary
+In non-leap years a Feb-29 birthday is treated as Feb-28, so the greeter says "It is X's birthday
+today" a day early.
+
+Location
+dotty-behaviour/household/registry.py:82-92
+
+Details
+self.birthdate.replace(year=ref.year) raises for Feb-29 in a common year and the except falls back to
+date(ref.year, month, 28); days_until_birthday()==0 then fires on Feb-28.
+
+Proposed fix
+Decide and document a deliberate Feb-29 policy (roll to Mar-1 in common years, or keep Feb-28 but make
+it intentional and consistent across both branches).
+
+Suggested labels: bug, area:behaviour
+```
+
+---
+
+## [LOW] Admin/behaviour HTTP clients disarm the timeout before reading the response body
+
+```
+Summary
+A server that sends headers then stalls the body hangs the voice tool forever — no timeout fires, no
+exception is thrown, so the try/catch fallbacks never run and the whole voice turn wedges.
+
+Location
+dotty-pi-ext/src/lib/xiaozhi_admin.ts:33-46; dotty-pi-ext/src/lib/dotty_behaviour.ts:20-37
+
+Details
+adminFetch/behaviourFetch arm an AbortController timer, await fetch() (resolves on headers), then clear
+the timer in finally — before any caller reads the body (fetchSongCatalog .json(), playAsset .text(),
+fetchTakePhoto/fetchPersonReviewStatus .json()). The sibling llama_swap.ts:42-71 does this correctly.
+
+Proposed fix
+Keep the timer armed across the body read: move the body read inside adminFetch/behaviourFetch (return
+parsed JSON/text) so the existing try/finally covers it, mirroring llama_swap.ts.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] play_song caches an empty catalogue on transient fetch failure for 60s
+
+```
+Summary
+A single transient xiaozhi hiccup pins an empty catalogue for the full 60s TTL, so play_song returns
+"(song catalogue is empty)" for up to a minute after recovery.
+
+Location
+dotty-pi-ext/src/tools/play_song.ts:83-90
+
+Details
+getCatalog unconditionally caches fetchSongCatalog's result, which returns [] on ANY failure — it
+cannot distinguish "no songs" from "fetch failed".
+
+Proposed fix
+Only cache non-empty results: if fresh.length > 0, cache; else return fresh without caching so the next
+turn retries.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] play_song matchSong: empty stem from a dotfile matches any query, diverging from the oracle
+
+```
+Summary
+A leading-dot catalogue entry matches every query and can win the best-candidate race, diverging from
+the Python oracle and violating the byte-equal contract.
+
+Location
+dotty-pi-ext/src/tools/play_song.ts:39-74
+
+Details
+stemLower computes the stem via lastIndexOf('.'); for '.mp3', dot===0 so the stem is '', and
+qStem.includes('') is always true. Python's os.path.splitext('.mp3') keeps '.mp3'.
+
+Proposed fix
+Match splitext semantics: only strip an extension when the dot index > 0 (`dot > 0 ? lower.slice(0,dot) : lower`).
+Guard the substring branch against an empty stem. Add a leading-dot fixture to play_song.test.ts.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] think_hard truncates by UTF-16 code units, diverging from the oracle and sibling tools
+
+```
+Summary
+think_hard caps the reply with .slice (UTF-16 code units) while the oracle and the other tools use
+codepoint slicing, so an emoji-prefixed near-cap reply mis-cuts.
+
+Location
+dotty-pi-ext/src/tools/think_hard.ts:72-77
+
+Details
+content.trim().slice(0, MAX_OUTPUT_CHARS). bridge.py oracle uses Python codepoint slicing [:500].
+memory_lookup/recall_person/remember/remember_person all use Array.from codepoint slicing; think_hard
+is the lone inconsistent path.
+
+Proposed fix
+Use codepoint-aware truncation like the sibling tools:
+const cp = Array.from(content.trim()); cp.length > MAX ? cp.slice(0, MAX).join('') : content.trim();
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] play_song host-presence guard ignores the _XIAOZHI_HOST fallback
+
+```
+Summary
+play_song refuses early with "(can't reach xiaozhi-server)" in an environment where only _XIAOZHI_HOST
+is set, even though the admin client would reach the server.
+
+Location
+dotty-pi-ext/src/tools/play_song.ts:104
+
+Details
+The guard checks `!opts.host && !process.env.XIAOZHI_HOST`, but DEFAULT_HOST resolves
+XIAOZHI_HOST ?? _XIAOZHI_HOST ?? 'localhost'. (No setter for _XIAOZHI_HOST today, so latent.)
+
+Proposed fix
+Use the same precedence as the admin client, or drop the guard and let fetchSongCatalog's empty-list
+fallback drive the result.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] extractTurnText concatenates assistant text blocks with no separator
+
+```
+Summary
+Multi-message/multi-block assistant turns are joined with the empty string, fusing fragments
+("Let me check…The answer is 4") in the logged turn.
+
+Location
+dotty-pi-ext/src/lib/turn_logger.ts:56-62 (join("")), 79-91
+
+Details
+extractTurnText joins assistantParts and TextContent items with "". No oracle exists for this
+extraction (pure pi-ext logic).
+
+Proposed fix
+Join multi-message assistant text and TextContent items with a separator (a space, or "\n").
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] think_hard default model resolved at module load, diverging from the per-call oracle
+
+```
+Summary
+DEFAULT_MODEL reads VOICE_THINKER_MODEL once at import; the oracle reads it per call, so a later env
+change diverges the request body.
+
+Location
+dotty-pi-ext/src/tools/think_hard.ts:25
+
+Details
+DEFAULT_MODEL = process.env.VOICE_THINKER_MODEL ?? 'qwen3.6:27b-think' is evaluated at import. The
+Python oracle resolves os.environ.get('VOICE_THINKER_MODEL', ...) on every call.
+
+Proposed fix
+Resolve the env lazily inside buildThinkRequest/runThinkHard at call time.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] play_song getCatalog TOCTOU lets concurrent turns both refetch
+
+```
+Summary
+Two interleaved play_song calls both see the stale timestamp and both issue a fetch; combined with the
+empty-cache bug, one can poison the other.
+
+Location
+dotty-pi-ext/src/tools/play_song.ts:83-90
+
+Details
+getCatalog reads _catalogFetchedAt, awaits fetchSongCatalog(), then writes the cache; the pi agent can
+run tool calls concurrently across the await.
+
+Proposed fix
+Store an in-flight Promise so concurrent callers await the same fetch, and cache only on a non-empty
+successful result (also resolves the empty-cache bug).
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] turn_logger.formatTurnLog omits the final strip the oracle applies (user-only turn divergence)
+
+```
+Summary
+Every user-only turn stores a row that is not byte-identical to the tuned-against oracle (trailing
+space after "assistant:").
+
+Location
+dotty-pi-ext/src/lib/turn_logger.ts:98-102
+
+Details
+formatTurnLog returns `user: ${u} | assistant: ${a}` directly; the oracle stores content.strip(). When
+the assistant text is empty (a logged user-only turn), TS produces "...assistant: " vs the oracle's
+"...assistant:". The integration test that would catch it (assistant_empty_user_only) only runs when
+DOTTY_BRAIN_DB_SNAPSHOT is set, which npm test never sets.
+
+Proposed fix
+return (`user: ${u} | assistant: ${a}`).trim(); wire the Layer-2 integration pass into npm test.
+
+Suggested labels: bug, area:dotty-pi
+```
+
+---
+
+## [LOW] Seqlock reader can return a torn read on weak memory (missing acquire barrier)
+
+```
+Summary
+A torn read can pass the seqlock check because the data reads can sink below the second seq acquire-load.
+
+Location
+firmware/firmware/main/stackchan/face/face_detection_result.h:33-47
+
+Details
+read() loads s1 (acquire), copies the plain data fields, loads s2 (acquire), accepts when s1==s2. An
+acquire load forbids later ops moving before it, not earlier plain reads from sinking below it. The
+writer side is correct; the reader is missing the symmetric barrier. (Low real-world hit-rate on
+Xtensa LX7.)
+
+Proposed fix
+Insert an acquire fence between the data copies and the second seq load:
+read the fields, then std::atomic_thread_fence(std::memory_order_acquire); then s2 = seq.load(relaxed).
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] Idle-channel proactive reconnect churns close+reopen every ~30 ticks
+
+```
+Summary
+A quiet-but-healthy idle channel close+reopens every ~30s indefinitely (a ~30s reconnect loop), each
+iteration paying a 200ms delay + full TLS/WS handshake on the main task.
+
+Location
+firmware/firmware/patches/xiaozhi-esp32.patch:23-32
+
+Details
+The reconnect fires when clock_ticks_ % 30 == 0 && state==Idle && protocol_->IsTimeout(). IsTimeout()
+is time-since-last-INCOMING; a reopened channel the server never sends on keeps IsTimeout() true. No
+backoff, no recently-reconnected suppression.
+
+Proposed fix
+Gate on an actual dead-channel signal (IsAudioChannelOpened() false) or a last-reconnect-timestamp
+backoff, or reset the incoming-frame clock on OpenAudioChannel() so a successful reopen clears IsTimeout().
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] CloseAudioChannel() blocks the calling task 200ms on every close
+
+```
+Summary
+An added vTaskDelay(200ms) stalls whatever task calls close (incl. the main Run loop) on every channel
+close, compounding the reconnect churn.
+
+Location
+firmware/firmware/patches/xiaozhi-esp32.patch:582
+
+Details
+The patch adds vTaskDelay(pdMS_TO_TICKS(200)) to WebsocketProtocol::CloseAudioChannel() after
+websocket_.reset(). The intent (drain the FIN) is reasonable but should not be a hard sleep on a
+shared task.
+
+Proposed fix
+Move the drain delay to only the reopen path that needs it (or poll socket state), or make close async,
+rather than unconditionally sleeping 200ms on the caller's task.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] PrivacyLeds::update() non-atomic RMW races the guard, latching the listening LED on
+
+```
+Summary
+The green mic privacy LED can keep showing "listening" after the mic ADC closed, lying about live
+capture state until the next repaint.
+
+Location
+firmware/firmware/main/stackchan/privacy/privacy_leds.cpp:49-60
+
+Details
+update() (tick task) load→derive→store of _mic_state is not atomic as a unit; MicPeripheralGuard's
+dtor (codec-close task) setMicState(Off) between the load and store is overwritten. Fail-safe in
+direction (over-indicates) but a privacy-indicator correctness bug.
+
+Proposed fix
+Make the reconciliation a CAS that only updates while non-Off: load s; if s==Off return; compute
+desired; compare_exchange_strong(s, desired).
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] CameraPeripheralGuard ctor-fallback/dtor-normal mismatch underflows the refcount
+
+```
+Summary
+A ctor that took the null-mutex fallback (no increment) followed by a normal dtor (fetch_sub) underflows
+g_refcount to UINT32_MAX, so the stream never tears down and the camera LED stays Active indefinitely.
+
+Location
+firmware/firmware/main/stackchan/privacy/camera_peripheral_guard.cpp:40-66,68-86
+
+Details
+The null-mutex ctor fallback sets CameraState::Active and returns WITHOUT incrementing g_refcount; the
+dtor unconditionally fetch_sub(1) on the normal path.
+
+Proposed fix
+Track per-guard whether the ctor incremented (bool _incremented) and only fetch_sub in the dtor when
+true. Clamp/guard against fetch_sub when g_refcount==0.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] MCP take_photo arms a fixed 10s camera-glow timer decoupled from capture duration
+
+```
+Summary
+The cosmetic camera-activity glow is hardcoded to 10s with no off-call, so it lingers after a fast
+capture or goes dark before a slow one.
+
+Location
+firmware/firmware/patches/xiaozhi-esp32.patch:523
+
+Details
+The take_photo patch adds GetHAL().setCameraLedActive(true, 10000) before camera->Capture(). The proper
+privacy LED is driven by CameraPeripheralGuard; this glow no longer tracks the real lifecycle.
+
+Proposed fix
+Tie the glow to the capture scope: set it active without a timeout and clear it after Capture() returns,
+or drive it from the CameraPeripheralGuard refcount transitions like the privacy pixel.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] Unescaped name / session_id in Protocol::SendEvent JSON construction
+
+```
+Summary
+SendEvent builds the perception frame by raw string concatenation; neither the event name nor the
+server-supplied session_id is escaped, so any future runtime name or a quoted session id emits
+malformed JSON the relay drops.
+
+Location
+firmware/firmware/patches/xiaozhi-esp32.patch:537-542
+
+Details
+Not currently exploitable (literal names, pre-escaped data, server-controlled session id), but SendEvent
+is the documented thread-safe perception-emit boundary with no escaping/validation.
+
+Proposed fix
+Build the frame with cJSON (escapes both name and session_id; attach pre-validated data_json as a parsed
+sub-object), or assert+escape and validate data_json parses.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] Debug log leftovers fire at WARN/ERROR on every WS and LLM frame
+
+```
+Summary
+An ESP_LOGW on every LLM frame and an ESP_LOGE on every inbound WS frame bypass log-level filtering,
+spam serial, and bury real errors.
+
+Location
+firmware/firmware/patches/xiaozhi-esp32.patch:65,590
+
+Details
+Patch line 65 logs WARN on every LLM frame; line 590 logs ERROR on every inbound WS frame (hello, tts,
+stt, llm, mcp, event acks).
+
+Proposed fix
+Drop these two lines from the patch, or demote to ESP_LOGD.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] HeadPet/Imu gesture flags are plain volatile bool, not atomic; fixed order can invert fast sequences
+
+```
+Summary
+A gesture can be lost (non-atomic read-then-clear across cores), and a fast release-then-press processed
+in fixed press→release order ends with _is_touched=false, silently never arming the hold-to-listen window.
+
+Location
+firmware/firmware/main/stackchan/modifiers/head_pet.h:50-52 (and head_pet.cpp:48-83, imu.h:124)
+
+Details
+_event_press/_event_swipe/_event_release/_event_shake are volatile bools written from the HAL signal
+callback (possibly a different core) and read+cleared on the tick task in a hardcoded order.
+
+Proposed fix
+Use std::atomic<bool> with exchange(false) to consume the flags, or post gestures through a FreeRTOS
+queue so they are consumed in arrival order.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] ParentalGate unlock at millis()==0 treated as "never unlocked"
+
+```
+Summary
+A successful unlock in the first millisecond after boot stores 0, which isUnlocked() treats as the
+"never" sentinel, so the unlock is silently dropped.
+
+Location
+firmware/firmware/main/stackchan/face/parental_gate.cpp:43,71-72
+
+Details
+_unlocked_at_ms uses 0 as the sentinel; tryUnlockByPIN/tryUnlockByLongPress store now_ms() which can be
+0 right after boot. (Dormant scaffold.)
+
+Proposed fix
+Use a separate atomic<bool> _is_unlocked alongside the timestamp, or store max(now,1) and treat 0
+strictly as "never".
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] CameraArbiter::acquireForCapture clears the shared _capture_pending on timeout
+
+```
+Summary
+_capture_pending is a single shared atomic, not per-call; a future second capture path plus a timeout
+could drop both callers' intent, wedging the other's still-pending capture.
+
+Location
+firmware/firmware/main/stackchan/face/camera_arbiter.cpp (header camera_arbiter.h:38-44)
+
+Details
+acquireForCapture() sets _capture_pending = true on entry and clears it to false on mutex-take timeout.
+Latent today (one Capture() caller) but contradicts the header's "two concurrent consumers compose
+cleanly".
+
+Proposed fix
+Make _capture_pending a refcount (fetch_add on entry, fetch_sub on timeout/release), or document+assert
+single-caller.
+
+Suggested labels: bug, area:firmware
+```
+
+---
+
+## [LOW] Whisper odd-length PCM buffer raises ValueError instead of degrading
+
+```
+Summary
+A truncated/short final VAD frame (odd byte count) discards the whole utterance as an empty transcript
+with no retry.
+
+Location
+custom-providers/asr/whisper_local.py:104
+
+Details
+np.frombuffer(artifacts.pcm_bytes, dtype=np.int16) raises ValueError on an odd byte count, caught by the
+broad except → ('', None). The failure is deterministic so the retry loop can't help.
+
+Proposed fix
+Trim to an even length before frombuffer:
+buf = artifacts.pcm_bytes; buf = buf[: len(buf) - (len(buf) % 2)].
+
+Suggested labels: bug, area:asr
+```
+
+---
+
+## [LOW] get_emotion matches the first mapped emoji anywhere, not the leading emoji; default 🙂 outside the set
+
+```
+Summary
+get_emotion can select a wrong/secondary face when a non-prefix emoji leaks into the reply, and its
+default 🙂 is outside the firmware-recognized set.
+
+Location
+custom-providers/textUtils.py:146-152
+
+Details
+The protocol requires the FIRST char to be the emotion emoji, but get_emotion breaks on the first
+EMOJI_MAP char wherever it appears; the default emoji='🙂'/emotion='happy' masks a missing prefix.
+
+Proposed fix
+Resolve emotion from the leading grapheme only (inspect text[0]), falling back to FALLBACK_EMOJI/😐
+rather than 🙂/happy.
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [LOW] piper effective_rate==24000 shortcut skips resampling when native rate isn't 24000
+
+```
+Summary
+A non-24000 Hz voice whose pitch_scale lands effective_rate on 24000 emits raw native-rate PCM into a
+24000 Hz encoder, playing back at the wrong speed/pitch.
+
+Location
+custom-providers/piper_local/piper_local.py:67-74
+
+Details
+The no-resample shortcut (self._up = self._down = 1) fires whenever effective_rate == 24000, conflating
+"no pitch shift" with "no rate conversion". The common default voice en_GB-cori-medium is 22050 Hz.
+
+Proposed fix
+Gate the shortcut on the SOURCE rate: only _up=_down=1 when src_rate==24000 AND pitch_scale==1.0.
+Otherwise always go through the gcd/resample branch (compute g=gcd(effective_rate,24000), up=24000//g,
+down=effective_rate//g unconditionally).
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [LOW] piper length_scale not validated for <= 0 (unlike pitch_scale)
+
+```
+Summary
+A configured length_scale <= 0 yields empty/garbage audio with no early error, while pitch_scale raises
+a clear ValueError.
+
+Location
+custom-providers/piper_local/piper_local.py:32-42
+
+Details
+pitch_scale is validated positive (33-36); length_scale is taken straight from config into
+SynthesisConfig(length_scale=float(length_scale)) with no bounds check.
+
+Proposed fix
+Mirror the pitch_scale guard: if length_scale is not None and float(length_scale) <= 0, raise
+ValueError. Construct self.syn_config only after the check.
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [LOW] whisper metrics: lang_prob can be None with forced language, dropping the ASR-METRICS line
+
+```
+Summary
+With a forced language, the #105 ASR-METRICS line is silently dropped on every utterance where
+language_probability is None.
+
+Location
+custom-providers/asr/whisper_local.py:132-137
+
+Details
+getattr(_info, "language_probability", 0.0) only fires when the attribute is ABSENT, not present-but-None;
+{lang_prob:.3f} then raises TypeError, swallowed by the surrounding try/except.
+
+Proposed fix
+lang_prob = getattr(_info, "language_probability", 0.0) or 0.0 (guards both absent and present-but-None).
+
+Suggested labels: bug, area:asr
+```
+
+---
+
+## [LOW] FIRST audio-start marker emitted even when synth yields zero audio
+
+```
+Summary
+A mid-reply empty-synth segment emits a FIRST marker with no frames and no LAST, wedging per-sentence
+marker accounting.
+
+Location
+custom-providers/edge_stream/edge_stream.py:101-115; piper_local.py:146-159 (mirror)
+
+Details
+text_to_speak puts (SentenceType.FIRST, [], text) before synthesis; on empty audio for a non-last
+segment it returns without enqueueing any frames or a terminator.
+
+Proposed fix
+Emit FIRST only after confirming there is audio, or on the empty-synth early return also enqueue a
+terminating marker so every FIRST is balanced. Apply to both files.
+
+Suggested labels: bug, area:tts
+```
+
+---
+
+## [LOW] security_watch defaults use retired RPi/zeroclaw paths and wrong port
+
+```
+Summary
+security_watch's CONVO_LOG_DIR default disagrees with dashboard.py, and _BRIDGE_INTERNAL_URL points at
+the wrong port (8080 vs the bridge's 8081).
+
+Location
+bridge/security_watch.py:85-101
+
+Details
+SECURITY_LOG_DIR defaults CONVO_LOG_DIR to /root/zeroclaw-bridge/logs (the retired RPi path) while
+dashboard.py defaults it to /var/lib/dotty-bridge/logs; _BRIDGE_INTERNAL_URL defaults to
+http://127.0.0.1:8080 while the bridge listens on 8081.
+
+Proposed fix
+Align the CONVO_LOG_DIR default with dashboard.py and fix _BRIDGE_INTERNAL_URL to :8081. Better: since
+the whole consumer is unreachable, delete the module or gate it behind a clear 'not wired' guard.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [LOW] Dashboard live perception feed (EventSource '/api/perception/feed') 404s — endpoint ripped in #111
+
+```
+Summary
+The dashboard's live perception EventSource 404s on the bridge (the endpoint was deleted in #111, the
+consumer left behind), so the feed never streams, every dotty-refresh nudge is dead, and the browser
+hammers a 404 reconnect every few seconds per open tab.
+
+Location
+bridge/templates/dashboard.html:564
+
+Details
+The page (served from :8081) opens EventSource('/api/perception/feed'), but the bridge serves no /api/*
+routes. Commit 30d9113 added the endpoint; c6df5c5 (#111) deleted it and left the EventSource. The real
+SSE lives on dotty-behaviour (routes/perception.py:127) at :8090 — a different origin.
+
+Proposed fix
+Add a bridge SSE passthrough route proxying dotty-behaviour's /api/perception/feed (under the /api/
+CSRF-exempt prefix) so the relative URL resolves, OR point the EventSource at the dotty-behaviour origin
+explicitly with CORS configured.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [LOW] play-asset / vision-photo proxy interpolate unencoded device_id into an internal URL
+
+```
+Summary
+_fetch_robot_photo builds the dotty-behaviour URL with the raw device_id path-param (unvalidated,
+unencoded), allowing query/fragment injection into the internal request.
+
+Location
+bridge/dashboard.py:201,638,1924
+
+Details
+f"{_DOTTY_BEHAVIOUR_URL}/api/vision/photo/{device_id}" with device_id from the URL; FastAPI path
+matching blocks literal /, but query/fragment chars still alter the request target.
+
+Proposed fix
+urllib.parse.quote(device_id, safe='') before interpolation, and validate device_id against an expected
+id charset (e.g. re.fullmatch(r'[A-Za-z0-9:_-]+', device_id)), returning 400 on mismatch.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [LOW] _dotty_behaviour_get caches the failure fallback for the full TTL
+
+```
+Summary
+A single transient dotty-behaviour failure pins an empty {}/[] result for the cache TTL, so every
+dashboard tile blanks for ~2s after each blip even after recovery.
+
+Location
+bridge.py:492-504
+
+Details
+On any timeout/connection/HTTP/JSON error the helper sets value = fallback and unconditionally writes it
+into _dotty_behaviour_cache with the full TTL.
+
+Proposed fix
+Only populate the cache on success (move the write inside the try after r.json()), returning fallback on
+the exception path without caching it.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [LOW] bridge writes to brain.db (RW) primarily owned by dotty-pi — approve/redact can lock or race
+
+```
+Summary
+The bridge's memory approve/redact open brain.db RW across containers; in non-WAL delete mode a writer
+blocks readers, and failures are swallowed and surface as a generic "not found".
+
+Location
+bridge.py:316,349
+
+Details
+_voice_memory_approve_blocking / _voice_memory_delete_blocking sqlite3.connect(str(_VOICE_MEMORY_DB))
+RW (timeout=5) against brain.db, which dotty-pi-ext actively writes. The list path correctly uses
+?mode=ro.
+
+Proposed fix
+Open with WAL-aware busy handling (PRAGMA busy_timeout); surface lock failures distinctly from
+'not found'. Longer term, route approve/redact through dotty-pi (the canonical writer).
+
+Suggested labels: bug, area:dashboard, area:dotty-pi
+```
+
+---
+
+## [LOW] host_detail 'server' modal hardcodes 'Recent errors today: —' despite the count being computed elsewhere
+
+```
+Summary
+The server host-detail modal shows a permanent dash for today's error count, even though the bridge
+already tallies it for the alerts chip.
+
+Location
+bridge/dashboard.py:1832
+
+Details
+The modal renders ('Recent errors today', '—') with a TODO, but alerts_count() (485-500) already counts
+rec.get('error') from the convo log.
+
+Proposed fix
+Factor the per-day error tally out of alerts_count() into a helper and reuse it. If the intent is
+xiaozhi-container errors specifically, note that in the label rather than a bare '—'.
+
+Suggested labels: bug, area:dashboard
+```
+
+---
+
+## [LOW] PiVoiceLLM fallback strings violate the mandatory emoji-prefix protocol
+
+```
+Summary
+PiVoiceLLM's server-generated fallback strings begin with '(', so the firmware emotion parser sees '('
+and produces no/garbage face state.
+
+Location
+custom-providers/pi_voice/pi_voice.py:130,150
+
+Details
+yield "(empty turn)" and yield "(brain offline — try again in a moment)" bypass the persona and lack an
+emoji prefix. OpenAICompat correctly prefixes all its fallbacks with FALLBACK_EMOJI.
+
+Proposed fix
+Prepend an allowed emoji to both fallbacks (e.g. "😐 (empty turn)", "😐 (brain offline — try again ...)"),
+or import ensure_emoji_prefix/FALLBACK_EMOJI from the shared textUtils.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] new_session response match does not verify request id
+
+```
+Summary
+new_session accepts a stale response from a previously-timed-out call because the drain loop never
+checks the request id.
+
+Location
+custom-providers/pi_voice/pi_client.py:192-209
+
+Details
+new_session sends req_id but the drain loop matches only type=='response' and command=='new_session',
+unlike iter_turn_text which matches the accept-ack by id.
+
+Proposed fix
+Add `and frame.get('id') == req_id` to the match condition.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] PiVoiceLLM _first_turn desyncs from the pi process after a respawn
+
+```
+Summary
+If pi dies after turn 1, the next turn runs new_session() against a freshly respawned process that has
+no session, producing a spurious 10s timeout and dead air.
+
+Location
+custom-providers/pi_voice/pi_voice.py:136-141
+
+Details
+_first_turn is tracked in PiVoiceLLM but the spawn decision lives in PiClient._ensure_started(); after a
+respawn _first_turn is False so new_session runs and waits up to 10s for an ack a clean process may
+never send.
+
+Proposed fix
+Have PiClient signal whether _ensure_started actually spawned a fresh process and skip new_session() in
+that case (or move the freshly-spawned suppression into PiClient.new_session()).
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] iter_turn_text process-exit detection only runs on queue-empty
+
+```
+Summary
+A pi crash with frames still queued is reported as a generic 120s turn timeout instead of "pi process
+exited", delaying the user-facing fallback by up to 2 minutes.
+
+Location
+custom-providers/pi_voice/pi_client.py:222-269
+
+Details
+The "pi process exited mid-turn" check is only reached inside the `except Empty` branch; if pi emits
+some frames then dies, the loop drains them without hitting Empty and spins to the turn timeout.
+
+Proposed fix
+Check self._proc.poll() is not None on every loop iteration and raise "pi process exited mid-turn"
+immediately when the process is gone and no agent_end has been seen.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] _next_id increments shared counter without the lock; reader-thread frame routing races a respawn
+
+```
+Summary
+A respawn swaps _event_queue while an old, never-joined reader thread can still put stale frames into
+the new queue, injecting a previous process's frames into the new turn.
+
+Location
+custom-providers/pi_voice/pi_client.py:283-285,149-169
+
+Details
+_next_id mutates _next_req_id outside _lock; _ensure_started() replaces _event_queue on every respawn;
+the stdout reader routes frames by reading self._event_queue live without the lock.
+
+Proposed fix
+Join (or signal-stop) the prior reader/stderr threads before swapping _event_queue, bind each reader to
+its specific Queue/proc instance (pass as args), and take the lock around _next_req_id mutation.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] _completions_url mishandles a base ending in /chat/completions
+
+```
+Summary
+A base_url whose path contains but doesn't end in /chat/completions (e.g. a gateway route
+/chat/completions/stream) gets a second /chat/completions appended.
+
+Location
+custom-providers/openai_compat/openai_compat.py:125-132
+
+Details
+The endsWith heuristic on an already-rstripped base appends /chat/completions when the base path
+contains the literal but isn't exactly it.
+
+Proposed fix
+Make the endpoint construction explicit via a config flag (url is base vs full endpoint), or document
+that url must be the base and drop the endswith special-case.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] OpenAICompat yields leading whitespace before emoji-prefix engages
+
+```
+Summary
+A whitespace-only first chunk is yielded to TTS before enforcement, so the first TTS chunk isn't the
+emoji the contract promises.
+
+Location
+custom-providers/openai_compat/openai_compat.py:218-229
+
+Details
+Enforcement fires only once so_far = ''.join(full_text).lstrip() is non-empty; a leading-whitespace
+content chunk is still emitted via yield content while emoji_checked is False.
+
+Proposed fix
+Buffer (do not yield) content until so_far is non-empty and the emoji check has run; strip leading
+whitespace from the first emitted chunk.
+
+Suggested labels: bug, area:voice
+```
+
+---
+
+## [LOW] OTAHandler.handle_post finally-block can swallow a secondary exception
+
+```
+Summary
+handle_post's finally calls _add_cors_headers with no try/except and a bare return that masks a
+propagating exception, so an edge case 500s the device with non-JSON.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:359-361
+
+Details
+handle_download wraps _add_cors_headers in try/except; handle_post does not, and the bare `return` in
+finally masks any exception from the except branch.
+
+Proposed fix
+Mirror handle_download: wrap _add_cors_headers in try/except; initialize response = None and
+short-circuit if still None.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] _dotty_inject_text reads conn.headers without the 'or {}' guard used by sibling handlers
+
+```
+Summary
+inject-text raises AttributeError (returning a misleading 500 after already dispatching chat) if
+conn.headers is present-but-None.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:66
+
+Details
+Line 66 does getattr(conn,'headers',{}).get('device-id',''); every other admin handler uses
+(getattr(conn,'headers',{}) or {}).get(...).
+
+Proposed fix
+Apply the same (getattr(conn,'headers',{}) or {}) guard on line 66.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] OTA mqtt branch ships an empty-password block with no websocket fallback
+
+```
+Summary
+A misconfigured MQTT signature key yields an mqtt config with a blank password and no websocket
+fallback — the device gets a connection config it cannot authenticate with.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:260-279
+
+Details
+When mqtt_gateway is configured but mqtt_signature_key is missing (or generate_password_signature
+fails), the handler sends mqtt with password:"" and, being exclusive with the websocket else, no
+alternate.
+
+Proposed fix
+If signature is required but unavailable, fall back to the websocket block (or return an error) rather
+than shipping an mqtt config with an empty password.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] OTA model-name matching is brittle — updates silently never offered
+
+```
+Summary
+device_model must exactly match the operator's bin-filename prefix; when they differ (the common case)
+the device is silently told it is up-to-date.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:84-90,200-201,304
+
+Details
+files_by_model.get(device_model, []) requires an exact string match; the StackChan board reports
+board.type, which rarely equals the human-chosen filename prefix. The same log fires for "model unknown"
+and "already latest".
+
+Proposed fix
+Log the parsed device_model + known model keys when candidates is empty; allow a configured fallback
+bucket or case-insensitive match; emit distinct log lines for the two cases.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] OTA timezone_offset / firmware_cache_ttl assume numeric YAML
+
+```
+Summary
+A quoted YAML timezone_offset ("8") produces a 60-copy string in the OTA payload; a non-int
+firmware_cache_ttl makes int(...) raise.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:62,226
+
+Details
+server_config.get("timezone_offset", 8) * 60 and int(self._bin_cache.get("ttl", 30)) trust the YAML
+type.
+
+Proposed fix
+Coerce with int(server_config.get("timezone_offset", 8)) * 60 and validate firmware_cache_ttl at
+construction (int() with try/except defaulting to 30).
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] Firmware bin cache re-scans disk on every OTA POST until a valid bin exists
+
+```
+Summary
+With no conforming bins yet, the TTL short-circuit never considers the cache warm, so the glob+regex
+scan + makedirs runs on every OTA POST.
+
+Location
+custom-providers/xiaozhi-patches/ota_handler.py:66-72
+
+Details
+The short-circuit requires a non-empty files_by_model; {} is falsy, so updated_at is bumped meaninglessly
+each pass and the scan never caches.
+
+Proposed fix
+Track freshness with a separate _scanned flag/updated_at sentinel independent of emptiness, so an
+empty-but-recent scan is honored for the TTL window.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] Admin MCP handlers fire-and-forget send() with no guard for a torn-down socket
+
+```
+Summary
+A single late send to an already-closed WS fails invisibly while the HTTP caller already got {"ok":true}.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:146,194,242,288,338
+
+Details
+Each direct-MCP route does _spawn(conn.websocket.send(msg), ...) after the registry lookup; between
+lookup and send executing, the WS can close (the registry pop is in the WS handler's finally), so
+send() raises in the spawned task.
+
+Proposed fix
+Wrap the send in a coroutine that checks conn.websocket state and catches+logs the exception, and/or
+await the send before returning so the HTTP response reflects whether the frame was queued.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] set-toggle/set-state have no response correlation; set-head-angles unclamped
+
+```
+Summary
+A device-side MCP rejection still returns {"ok":true} (no response correlation), and set-head-angles
+forwards arbitrary ints with no clamp.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:143,191,239,285,335
+
+Details
+MCP calls use a truncated wall-clock id and the handler returns before any response frame; set_head_angles
+validates only type, so a 100000 speed or 999 yaw is sent verbatim.
+
+Proposed fix
+Clamp set-head-angles yaw/pitch/speed to firmware-legal ranges before sending. Optionally correlate by
+request id with a timeout, or document the endpoints as best-effort.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] play-asset format inference treats bare .opus as Ogg
+
+```
+Summary
+A .opus asset shown in the songs picker can fail to play (forced format=ogg fails on raw Opus) with only
+a swallowed warning behind an already-sent 200.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:406-411
+
+Details
+fmt is derived from the extension; {"opus":"ogg",...}.get(ext) forces .opus to ogg, and unmapped
+extensions yield fmt=None (autodetect) with no distinct log.
+
+Proposed fix
+Let ffmpeg autodetect for .opus (pass no explicit format); on decode failure return a distinguishable
+error code rather than a swallowed warning behind a 200.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] play-asset resample can feed huge factors to resample_poly; no sample_rate guard
+
+```
+Summary
+Coprime rates give large up/down factors (slow/memory-heavy filter), and a 0/None conn.sample_rate blows
+up inside _decode masked by the broad except.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:415-420
+
+Details
+g = gcd(src_rate, tgt); resample_poly(pcm, tgt//g, src_rate//g). No guard that conn.sample_rate is a
+positive int; failures are logged as 'decode failed', hiding the cause.
+
+Proposed fix
+Validate conn.sample_rate > 0 (return 400/503 if not); log the actual src/tgt rates on decode failure;
+consider capping or special-casing common rates.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] Admin routes resolve target via next(iter(...)) — nondeterministic device with multiple StackChans
+
+```
+Summary
+With more than one device connected and no device_id, admin handlers act on an arbitrary dict entry, so
+abort/set-state can hit the wrong robot.
+
+Location
+custom-providers/xiaozhi-patches/http_server.py:55,87,123,171,218,266,316,388,523
+
+Details
+next(iter(_dotty_active_connections.values()), None) picks the first dict entry; the caller has no way
+to know which device was targeted.
+
+Proposed fix
+When multiple devices are connected and no device_id is given, return 409/400 requiring an explicit
+device_id (or target all). Single-device deployments are unaffected.
+
+Suggested labels: bug, area:xiaozhi
+```
+
+---
+
+## [LOW] EventTextMessageHandler attributes events to "unknown" device on header miss
+
+```
+Summary
+If conn.headers is None, the relayed perception event is attributed to device "unknown", which never
+matches the real device id used by the admin routes, so per-device consumers silently never fire.
+
+Location
+custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py:60-65
+
+Details
+handle() does device_id = conn.headers.get("device-id","unknown") inside a bare try/except that swallows
+all exceptions, leaving device_id="unknown".
+
+Proposed fix
+Resolve device_id like the WS registration ((getattr(conn,"headers",None) or {}).get("device-id")); if
+it resolves falsy/"unknown", drop the event with a warning rather than relay under a fabricated id.
+
+Suggested labels: bug, area:xiaozhi, area:behaviour
+```
diff --git a/bridge.py b/bridge.py
index b4783d23..5bbf2ad5 100644
--- a/bridge.py
+++ b/bridge.py
@@ -15,12 +15,14 @@
 """
 
 import asyncio
+import hmac
 import json
 import logging
 import os
 import re
 import sys
 import time
+from collections import deque
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any
@@ -596,25 +598,19 @@ def _dashboard_last_user_line_getter(device_id: str) -> dict | None:
     return None
 
 
-def _dashboard_sound_balance_series() -> list[float]:
-    """Live sound_event balance series from dotty-behaviour.
+def _dashboard_open_perception_feed() -> Any:
+    """Open dotty-behaviour's perception SSE stream for the dashboard proxy.
 
-    Picks the first device with perception state (single-robot
-    deployment heuristic — matches the device-picking strategy used
-    for the perception card) and reads its sound-balance ring via
-    /api/perception/sound-balance/{device_id}. Same cache + timeout +
-    circuit-breaker contract as the other dotty-behaviour-backed
-    getters — returns ``[]`` on any failure."""
-    state = _dashboard_perception_state_getter()
-    device_id = next(iter(state), None) if isinstance(state, dict) else None
-    if not device_id:
-        return []
-    result = _dotty_behaviour_get(
-        f"/api/perception/sound-balance/{device_id}",
-        {"limit": 30},
-        [],
+    Returns a streaming ``requests.Response`` (caller closes it). The read
+    timeout sits above the upstream's 15 s keepalive so an idle-but-healthy
+    stream never trips it. Raises on connect failure / non-2xx."""
+    r = requests.get(
+        f"{DOTTY_BEHAVIOUR_URL}/api/perception/feed",
+        stream=True,
+        timeout=(_DOTTY_BEHAVIOUR_TIMEOUT_SEC, 30.0),
     )
-    return result if isinstance(result, list) else []
+    r.raise_for_status()
+    return r
 
 
 def _dashboard_vision_failures_last_hour() -> dict[str, int]:
@@ -631,10 +627,30 @@ def _identity_display_name(identity: str) -> str | None:
     return None
 
 
-# Stub SSE plumbing — kept so /ui/events still wakes the queue handler
-# (sends heartbeats) when the browser subscribes. No producer is wired in
-# bridge.py post-#111; convo turns are owned by dotty-pi now.
+# Turn stream — /ui/events subscribers plus the recent-turns ring behind
+# the Turns tab, Errors count and error report. Voice turns are owned by
+# dotty-pi since #111, so the PiVoiceLLM provider reports each completed
+# turn to /api/voice/turn (below). In-memory ONLY: the ring is lost on
+# restart and transcripts are never written to disk.
 _dashboard_event_listeners: list[asyncio.Queue] = []
+_DASHBOARD_TURNS_MAX = 200
+_dashboard_recent_turns: "deque[dict]" = deque(maxlen=_DASHBOARD_TURNS_MAX)
+
+
+def _dashboard_publish_turn(record: dict) -> None:
+    """Record a completed turn and fan it out to /ui/events subscribers.
+    A slow subscriber's full queue drops the event rather than blocking."""
+    _dashboard_recent_turns.append(record)
+    for q in list(_dashboard_event_listeners):
+        try:
+            q.put_nowait(record)
+        except asyncio.QueueFull:
+            pass
+
+
+def _dashboard_recent_turns_getter() -> list[dict]:
+    """Recent turns, oldest first."""
+    return list(_dashboard_recent_turns)
 
 
 def _dashboard_subscribe_events() -> asyncio.Queue:
@@ -764,6 +780,7 @@ async def _dashboard_memory_redact(mem_id: str) -> dict:
         abort_device=_dashboard_abort_device,
         subscribe_events=_dashboard_subscribe_events,
         unsubscribe_events=_dashboard_unsubscribe_events,
+        recent_turns_getter=_dashboard_recent_turns_getter,
         perception_state_getter=_dashboard_perception_state_getter,
         perception_recent_getter=_dashboard_perception_recent_getter,
         memory_records_getter=_dashboard_memory_records,
@@ -771,11 +788,74 @@ async def _dashboard_memory_redact(mem_id: str) -> dict:
         memory_redact=_dashboard_memory_redact,
         identity_display_name=_identity_display_name,
         last_user_line_getter=_dashboard_last_user_line_getter,
-        sound_balance_getter=_dashboard_sound_balance_series,
+        perception_feed_opener=_dashboard_open_perception_feed,
         vision_failures_getter=_dashboard_vision_failures_last_hour,
     )
 
 
+# ---------------------------------------------------------------------------
+# /api/voice/* — turn + filter-hit reports from the voice provider
+# ---------------------------------------------------------------------------
+# PiVoiceLLM runs inside the xiaozhi container, so the bridge only learns
+# about a voice turn if the provider tells it. Guarded by the same shared
+# X-Admin-Token as /xiaozhi/admin/* when DOTTY_ADMIN_TOKEN is set; open on
+# the LAN otherwise, matching the rest of the stack's unset-token posture.
+
+_VOICE_TEXT_MAX = 2000
+
+
+def _voice_require_admin_token(request: Request) -> None:
+    if not _ADMIN_TOKEN:
+        return
+    supplied = request.headers.get("X-Admin-Token", "")
+    if not hmac.compare_digest(supplied.encode(), _ADMIN_TOKEN.encode()):
+        raise HTTPException(status_code=401, detail="bad admin token")
+
+
+class _VoiceTurnIn(BaseModel):
+    request_text: str = ""
+    response_text: str = ""
+    latency_ms: int | None = None
+    error: str | None = None
+    channel: str = "dotty"
+
+
+class _VoiceFilterHitIn(BaseModel):
+    tier: str
+    rule: str = ""
+    prefix: str = ""
+
+
+_voice_router = APIRouter(
+    prefix="/api/voice", dependencies=[Depends(_voice_require_admin_token)],
+)
+
+
+@_voice_router.post("/turn")
+async def _voice_turn(payload: _VoiceTurnIn) -> dict:
+    _dashboard_publish_turn({
+        "ts": time.time(),
+        "channel": payload.channel[:32] or "dotty",
+        "request_text": payload.request_text[:_VOICE_TEXT_MAX],
+        "response_text": payload.response_text[:_VOICE_TEXT_MAX],
+        "latency_ms": payload.latency_ms,
+        "error": (payload.error or "")[:500] or None,
+    })
+    return {"ok": True}
+
+
+@_voice_router.post("/filter-hit")
+async def _voice_filter_hit(payload: _VoiceFilterHitIn) -> dict:
+    from bridge.text import record_content_filter_hit
+    record_content_filter_hit(
+        payload.tier[:16], payload.rule[:64], payload.prefix,
+    )
+    return {"ok": True}
+
+
+app.include_router(_voice_router)
+
+
 # ---------------------------------------------------------------------------
 # /admin/* — localhost-only runtime configuration mutations
 # ---------------------------------------------------------------------------
diff --git a/bridge/dashboard.py b/bridge/dashboard.py
index 6ff97548..a3382191 100644
--- a/bridge/dashboard.py
+++ b/bridge/dashboard.py
@@ -46,6 +46,7 @@
     "abort_device": None,
     "subscribe_events": None,
     "unsubscribe_events": None,
+    "recent_turns_getter": None,
     "perception_state_getter": None,
     "perception_recent_getter": None,
     "identity_display_name": None,
@@ -53,7 +54,7 @@
     "memory_records_getter": None,
     "memory_approve": None,
     "memory_redact": None,
-    "sound_balance_getter": None,
+    "perception_feed_opener": None,
     "vision_failures_getter": None,
 }
 
@@ -67,6 +68,7 @@ def configure(*, send_message: Any = None, vision_cache_getter: Any = None,
               inject_to_device: Any = None, abort_device: Any = None,
               subscribe_events: Any = None,
               unsubscribe_events: Any = None,
+              recent_turns_getter: Any = None,
               perception_state_getter: Any = None,
               perception_recent_getter: Any = None,
               identity_display_name: Any = None,
@@ -74,7 +76,7 @@ def configure(*, send_message: Any = None, vision_cache_getter: Any = None,
               memory_records_getter: Any = None,
               memory_approve: Any = None,
               memory_redact: Any = None,
-              sound_balance_getter: Any = None,
+              perception_feed_opener: Any = None,
               vision_failures_getter: Any = None) -> None:
     """Register bridge state with the dashboard. Idempotent."""
     if send_message is not None:
@@ -105,6 +107,8 @@ def configure(*, send_message: Any = None, vision_cache_getter: Any = None,
         _state["subscribe_events"] = subscribe_events
     if unsubscribe_events is not None:
         _state["unsubscribe_events"] = unsubscribe_events
+    if recent_turns_getter is not None:
+        _state["recent_turns_getter"] = recent_turns_getter
     if perception_state_getter is not None:
         _state["perception_state_getter"] = perception_state_getter
     if perception_recent_getter is not None:
@@ -119,8 +123,8 @@ def configure(*, send_message: Any = None, vision_cache_getter: Any = None,
         _state["memory_approve"] = memory_approve
     if memory_redact is not None:
         _state["memory_redact"] = memory_redact
-    if sound_balance_getter is not None:
-        _state["sound_balance_getter"] = sound_balance_getter
+    if perception_feed_opener is not None:
+        _state["perception_feed_opener"] = perception_feed_opener
     if vision_failures_getter is not None:
         _state["vision_failures_getter"] = vision_failures_getter
 
@@ -298,7 +302,6 @@ def _xiaozhi_admin_headers() -> dict[str, str]:
     is set (matches the xiaozhi-server middleware); empty otherwise."""
     return {"X-Admin-Token": _ADMIN_TOKEN} if _ADMIN_TOKEN else {}
 LOG_DIR = Path(os.environ.get("CONVO_LOG_DIR", "/var/lib/dotty-bridge/logs"))
-VOICE_CHANNELS = ("dotty", "stackchan")
 
 _START_TIME = time.time()
 
@@ -340,12 +343,27 @@ def _humanize_age(seconds: float) -> str:
     return f"{s // 86400}d"
 
 
-def _today_log_path() -> Path:
-    return _log_path_for(datetime.now().strftime("%Y-%m-%d"))
+def _recent_turns() -> list[dict]:
+    """Recent voice turns from the bridge's in-memory ring, oldest first.
+    Empty after a bridge restart — nothing is persisted."""
+    getter = _state.get("recent_turns_getter")
+    try:
+        return list(getter()) if getter else []
+    except Exception:
+        return []
 
 
-def _log_path_for(date_str: str) -> Path:
-    return LOG_DIR / f"convo-{date_str}.ndjson"
+def _errored_turns_today() -> list[dict]:
+    """Today's (local date) errored turns, newest first."""
+    today = datetime.now().date()
+    out: list[dict] = []
+    for rec in reversed(_recent_turns()):
+        ts = rec.get("ts")
+        if not rec.get("error") or not isinstance(ts, (int, float)):
+            continue
+        if datetime.fromtimestamp(ts).date() == today:
+            out.append(rec)
+    return out
 
 
 def _clean_request_text(s: str) -> str:
@@ -372,37 +390,34 @@ def _clean_request_text(s: str) -> str:
     return after
 
 
-def _parse_ts(ts: str) -> float | None:
-    if not ts:
-        return None
+def _stackchan_last_seen() -> float | None:
+    """Timestamp of the most recent voice activity.
+
+    Prefers the newest reported turn; falls back to dotty-behaviour's
+    per-device `last_chat_t`, which also covers the window after a bridge
+    restart when the turn ring is empty."""
+    return _last_turn_ts() or _perception_last_chat_ts()
+
+
+def _perception_last_chat_ts() -> float | None:
+    getter = _state.get("perception_state_getter")
     try:
-        return datetime.fromisoformat(ts.replace("Z", "+00:00")).timestamp()
+        pstate = (getter() if getter else None) or {}
     except Exception:
         return None
+    stamps = [
+        d["last_chat_t"] for d in pstate.values()
+        if isinstance(d, dict) and isinstance(d.get("last_chat_t"), (int, float))
+    ]
+    return max(stamps) if stamps else None
 
 
-def _stackchan_last_seen() -> float | None:
-    """Timestamp of the most recent voice-channel turn in today's log."""
-    path = _today_log_path()
-    if not path.exists():
-        return None
-    try:
-        data = path.read_bytes()
-    except OSError:
-        return None
-    last_voice_ts: float | None = None
-    for line in data.splitlines():
-        if not line.strip():
-            continue
-        try:
-            rec = json.loads(line)
-        except Exception:
-            continue
-        if rec.get("channel") in VOICE_CHANNELS:
-            ts = _parse_ts(rec.get("ts", ""))
-            if ts is not None:
-                last_voice_ts = ts
-    return last_voice_ts
+def _last_turn_ts() -> float | None:
+    for rec in reversed(_recent_turns()):
+        ts = rec.get("ts")
+        if isinstance(ts, (int, float)):
+            return float(ts)
+    return None
 
 
 @router.get("", response_class=HTMLResponse, include_in_schema=False)
@@ -479,7 +494,7 @@ async def device_status(request: Request) -> Any:
 
 @router.get("/alerts/count", response_class=HTMLResponse, include_in_schema=False)
 async def alerts_count(request: Request, chip: int = 0) -> Any:
-    """Q6: count today's errored turns from the convo log.
+    """Q6: count today's errored turns from the recent-turns ring.
 
     Two render modes share the same count so the dashboard polls one URL:
       - default: legacy floating ``alerts_badge.html`` (kept for
@@ -490,22 +505,7 @@ async def alerts_count(request: Request, chip: int = 0) -> Any:
         the chip. innerHTML swap target is the chip itself, so the script
         runs against its own parent element.
     """
-    today = datetime.now().strftime("%Y-%m-%d")
-    path = _log_path_for(today)
-    n = 0
-    if path.exists():
-        try:
-            for line in path.read_bytes().splitlines():
-                if not line.strip():
-                    continue
-                try:
-                    rec = json.loads(line)
-                except Exception:
-                    continue
-                if rec.get("error"):
-                    n += 1
-        except OSError:
-            pass
+    n = len(_errored_turns_today())
     if chip:
         # Don't tint the chip red — selection (`btn-primary` via setFeedFilter)
         # is the only "selected" cue; the chip just shows a warning glyph +
@@ -526,37 +526,15 @@ async def alerts_count(request: Request, chip: int = 0) -> Any:
 async def alerts_detail(request: Request) -> Any:
     """F13: render today's errored turns. Opened via the alerts-badge
     modal in dashboard.html."""
-    today = datetime.now().strftime("%Y-%m-%d")
-    path = _log_path_for(today)
     entries: list[dict[str, Any]] = []
-    if path.exists():
-        try:
-            lines = path.read_bytes().splitlines()
-        except OSError:
-            lines = []
-        for line in reversed(lines):
-            if not line.strip():
-                continue
-            try:
-                rec = json.loads(line)
-            except Exception:
-                continue
-            if not rec.get("error"):
-                continue
-            ts = rec.get("ts", "")
-            try:
-                time_str = datetime.fromisoformat(
-                    ts.replace("Z", "+00:00")
-                ).astimezone().strftime("%H:%M:%S")
-            except Exception:
-                time_str = ts[-8:] if ts else "?"
-            entries.append({
-                "time": time_str,
-                "channel": rec.get("channel") or "?",
-                "request": _clean_request_text(rec.get("request_text") or "")[:400],
-                "response": (rec.get("response_text") or "")[:300],
-                "error": str(rec.get("error"))[:500],
-            })
+    for rec in _errored_turns_today():
+        entries.append({
+            "time": datetime.fromtimestamp(rec["ts"]).astimezone().strftime("%H:%M:%S"),
+            "channel": rec.get("channel") or "?",
+            "request": _clean_request_text(rec.get("request_text") or "")[:400],
+            "response": (rec.get("response_text") or "")[:300],
+            "error": str(rec.get("error"))[:500],
+        })
     return templates.TemplateResponse(
         request, "alerts_detail.html",
         {"entries": entries},
@@ -663,17 +641,13 @@ def _post() -> dict:
     return templates.TemplateResponse(request, "say_result.html", result)
 
 
-_INJECT_WAIT_SEC = 8.0  # Q4: how long to wait for Dotty's reply before
-                        #     showing "no response in time" fallback.
-
-
 async def _inject_or_error(request: Request, text: str, label: str) -> Any:
     """Helper for action endpoints that fire text into xiaozhi-server's
     pipeline so the device actually speaks/emotes/runs MCP tools.
 
-    Q4: subscribes to the bridge's event stream BEFORE injecting, then
-    waits up to ~8s for the next turn so the dashboard can show what Dotty
-    actually said (not just "Sent…")."""
+    Returns as soon as the inject is accepted. It used to wait ~8 s for the
+    reply on the bridge's turn stream, but turns are owned by dotty-pi since
+    #111 and nothing publishes them here — the wait only ever timed out."""
     inject = _state.get("inject_to_device")
     if inject is None:
         return templates.TemplateResponse(
@@ -681,38 +655,22 @@ async def _inject_or_error(request: Request, text: str, label: str) -> Any:
             {"ok": False,
              "error": "Inject path not configured (xiaozhi admin patch missing)."},
         )
-    subscribe = _state.get("subscribe_events")
-    unsubscribe = _state.get("unsubscribe_events")
-    queue = subscribe() if subscribe else None
     try:
-        try:
-            result = await inject(text=text)
-        except Exception as exc:
-            log.exception("dashboard inject failed")
-            return templates.TemplateResponse(
-                request, "say_result.html",
-                {"ok": False, "error": f"Bridge error: {exc.__class__.__name__}"},
-            )
-        if not result.get("ok"):
-            return templates.TemplateResponse(
-                request, "say_result.html",
-                {"ok": False, "error": result.get("error", "unknown injection failure")},
-            )
-        # Wait for the next completed turn (likely ours — single device).
-        response_text = "Sent — no reply in 8s."
-        if queue is not None:
-            try:
-                event = await asyncio.wait_for(queue.get(), timeout=_INJECT_WAIT_SEC)
-                response_text = event.get("response_text") or "(no text)"
-            except asyncio.TimeoutError:
-                pass
+        result = await inject(text=text)
+    except Exception as exc:
+        log.exception("dashboard inject failed")
         return templates.TemplateResponse(
             request, "say_result.html",
-            {"ok": True, "sent": label, "response": response_text},
+            {"ok": False, "error": f"Bridge error: {exc.__class__.__name__}"},
         )
-    finally:
-        if queue is not None and unsubscribe is not None:
-            unsubscribe(queue)
+    if not result.get("ok"):
+        return templates.TemplateResponse(
+            request, "say_result.html",
+            {"ok": False, "error": result.get("error", "unknown injection failure")},
+        )
+    return templates.TemplateResponse(
+        request, "say_result.html", {"ok": True, "sent": label},
+    )
 
 
 def _kid_blocked(text: str) -> bool:
@@ -954,29 +912,6 @@ async def kid_mode_partial(request: Request) -> Any:
 }
 
 
-def _sound_balance_sparkline() -> dict | None:
-    """Build the State-tile sound-balance sparkline (#69) — an SVG
-    polyline over the last 60 s of localizer `balance` samples. Returns
-    None when there's no recent sound data (fewer than 2 points)."""
-    getter = _state.get("sound_balance_getter")
-    series = getter() if getter else []
-    if not series or len(series) < 2:
-        return None
-    width, height = 100.0, 24.0
-    n = len(series)
-    pts: list[str] = []
-    for i, bal in enumerate(series):
-        x = (i / (n - 1)) * width
-        y = (1.0 - max(0.0, min(1.0, float(bal)))) * height
-        pts.append(f"{x:.1f},{y:.1f}")
-    return {
-        "points": " ".join(pts),
-        "last": series[-1],
-        "width": width,
-        "height": height,
-    }
-
-
 def _vision_failures_count() -> int:
     """Total vision-capture failures in the last hour (#74) — summed
     across error kinds. 0 when the getter is unwired or the window is
@@ -1002,21 +937,25 @@ async def state_partial(request: Request) -> Any:
             "states": _STATES,
             "labels": _STATE_LABELS,
             "descriptions": _STATE_DESCRIPTIONS,
-            "sound_spark": _sound_balance_sparkline(),
         },
     )
 
 
 # #65 tier 1 — voice tool inventory. Hardcoded list of the tools shipped
 # by dotty-pi-ext (see dotty-pi-ext/package.json). Per the issue body the
-# static list is intentional: "hardcoded; same five values until a sixth
-# tool ships". Tier 2 (call counts via PiClient stdout parsing) and Tier 3
-# (safety-denial counts) are deferred follow-ups.
+# static list is intentional — keep it in step with dotty-pi-ext/src/tools/
+# (seven tools since #53 added recall_person / remember_person). Tier 2
+# (call counts via PiClient stdout parsing) and Tier 3 (safety-denial
+# counts) are deferred follow-ups.
 _VOICE_TOOLS: list[dict[str, str]] = [
     {"name": "memory_lookup",
      "description": "Search Dotty's long-term memory by keyword"},
     {"name": "remember",
      "description": "Save a new memory (\"Brett's birthday is …\")"},
+    {"name": "recall_person",
+     "description": "Look up what Dotty knows about a named person"},
+    {"name": "remember_person",
+     "description": "Save a fact about a named person (kid-mode: pending review)"},
     {"name": "think_hard",
      "description": "Hand a hard reasoning task to the bigger 27B model"},
     {"name": "take_photo",
@@ -1815,7 +1754,7 @@ async def host_detail(request: Request, slug: str) -> Any:
         smart_on = bool(smart_getter()) if smart_getter else None
         active_llm = _host_detail_llm_label(smart_on)
         facts = [
-            ("Device",     "Raspberry Pi"),
+            ("Device",     "Docker container (dotty-bridge)"),
             ("Status",     "online"),
             ("Version",    BRIDGE_VERSION),
             ("Uptime",     _humanize_age(time.time() - _START_TIME)),
@@ -2099,6 +2038,54 @@ async def security_recent(request: Request, device_id: str) -> Any:
     return templates.TemplateResponse(request, "security_panel.html", ctx)
 
 
+# --- Perception feed proxy ------------------------------------------------
+
+@router.get("/perception/feed", include_in_schema=False)
+async def perception_feed_proxy(request: Request) -> StreamingResponse:
+    """Relay dotty-behaviour's perception SSE stream to the browser.
+
+    The perception bus moved to dotty-behaviour in #36, but the page can
+    only open same-origin EventSources — so the bridge relays the stream
+    line-for-line. If the upstream is down or drops, the stream just ends
+    and EventSource reconnects after the `retry` interval (a non-200 would
+    stop it retrying for good)."""
+    opener = _state.get("perception_feed_opener")
+
+    async def gen():
+        yield b"retry: 5000\n\n"
+        if opener is None:
+            return
+        try:
+            upstream = await asyncio.to_thread(opener)
+        except Exception as exc:
+            log.warning("perception feed upstream unavailable: %s", exc)
+            return
+        lines = upstream.iter_lines(chunk_size=1)
+        try:
+            while True:
+                if await request.is_disconnected():
+                    break
+                try:
+                    line = await asyncio.to_thread(next, lines, None)
+                except Exception as exc:
+                    log.warning("perception feed upstream dropped: %s", exc)
+                    break
+                if line is None:
+                    break
+                yield line + b"\n"
+        finally:
+            upstream.close()
+
+    return StreamingResponse(
+        gen(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
 # --- P13 + P12: SSE event stream for live log + error toasts -------------
 
 @router.get("/events", include_in_schema=False)
@@ -2106,8 +2093,8 @@ async def events_stream(request: Request) -> StreamingResponse:
     """Server-Sent Events stream of completed conversation turns.
 
     Each event is one JSON object: {ts, channel, request_text, response_text,
-    latency_ms, error, emoji_used}. The bridge's ConvoLogger broadcasts on
-    every turn. Heartbeats every 15s keep proxies / browsers awake.
+    latency_ms, error}. Published when the voice provider reports a turn to
+    /api/voice/turn. Heartbeats every 15s keep proxies / browsers awake.
     """
     subscribe = _state.get("subscribe_events")
     unsubscribe = _state.get("unsubscribe_events")
diff --git a/bridge/templates/dashboard.html b/bridge/templates/dashboard.html
index 075eceeb..89913d15 100644
--- a/bridge/templates/dashboard.html
+++ b/bridge/templates/dashboard.html
@@ -561,7 +561,7 @@ <h3 class="text-lg font-semibold mb-2">Latest vision capture</h3>
   }
   (function () {
     if (typeof EventSource === 'undefined') return;
-    var psrc = new EventSource('/api/perception/feed');
+    var psrc = new EventSource('/ui/perception/feed');
     psrc.onmessage = function (ev) {
       var data;
       try { data = JSON.parse(ev.data); } catch (e) { return; }
diff --git a/bridge/templates/say_result.html b/bridge/templates/say_result.html
index a5e61f35..d99f54db 100644
--- a/bridge/templates/say_result.html
+++ b/bridge/templates/say_result.html
@@ -1,10 +1,12 @@
 {% if ok %}
 <div class="alert alert-success dotty-alert">
   <div>
-    <div class="text-xs text-base-content/60">you said</div>
+    <div class="text-xs text-base-content/60">{% if response %}you said{% else %}sent to Dotty{% endif %}</div>
     <div class="break-words">{{ sent }}</div>
+    {% if response %}
     <div class="text-xs text-base-content/60 mt-2">Dotty replied</div>
     <div class="break-words whitespace-pre-wrap">{{ response }}</div>
+    {% endif %}
   </div>
 </div>
 {% else %}
diff --git a/bridge/templates/state.html b/bridge/templates/state.html
index be57f940..0724261f 100644
--- a/bridge/templates/state.html
+++ b/bridge/templates/state.html
@@ -44,21 +44,6 @@
   </div>
   {% endif %}
 
-  {% if sound_spark %}
-  {# #69 — sound-localizer balance over the last 60 s. 0.5 is centred;
-     a flat line near 1.0 is the stuck-left bias tracked in #27. #}
-  <div class="mt-2 flex items-center gap-2" title="Sound-localizer balance, last 60 s">
-    <span class="text-xs text-base-content/50 whitespace-nowrap">Sound balance</span>
-    <svg viewBox="0 0 {{ sound_spark.width }} {{ sound_spark.height }}"
-         class="flex-1 h-6" preserveAspectRatio="none" aria-hidden="true">
-      <polyline points="{{ sound_spark.points }}"
-                fill="none" stroke="#22c55e" stroke-width="1.5"
-                vector-effect="non-scaling-stroke" />
-    </svg>
-    <span class="text-xs font-mono text-base-content/40">{{ "%.2f"|format(sound_spark.last) }}</span>
-  </div>
-  {% endif %}
-
   <div id="state-result" class="mt-2 empty:hidden"></div>
 </div>
 <script>
diff --git a/bridge/text.py b/bridge/text.py
index fa622088..f26c6f66 100644
--- a/bridge/text.py
+++ b/bridge/text.py
@@ -144,15 +144,23 @@ def content_filter(text: str) -> str | None:
         "content-filter-hit tier=%s pattern=%r pos=%d len=%d",
         tier, match.group(), match.start(), len(text),
     )
+    record_content_filter_hit(tier, match.group(), text[:8])
+    return CONTENT_FILTER_REPLACEMENT
+
+
+def record_content_filter_hit(tier: str, rule: str, prefix: str = "") -> None:
+    """Add a hit to the /ui/safety/recent ring and bump the Prometheus
+    counter. Called by content_filter() and by the /api/voice/filter-hit
+    ingress, where the voice provider reports hits it made in the xiaozhi
+    container."""
     _cf_recent.append({
         "ts": time.time(),
         "tier": tier,
-        "rule": match.group(),
-        "prefix": text[:8],
+        "rule": rule,
+        "prefix": prefix[:8],
     })
     if dotty_content_filter_hits_total is not None:
         try:
             dotty_content_filter_hits_total.labels(tier=tier).inc()
         except Exception:
             pass
-    return CONTENT_FILTER_REPLACEMENT
diff --git a/custom-providers/asr/whisper_local.py b/custom-providers/asr/whisper_local.py
index f5c24e8d..4260cd9b 100644
--- a/custom-providers/asr/whisper_local.py
+++ b/custom-providers/asr/whisper_local.py
@@ -15,6 +15,16 @@
 
 MAX_RETRIES = 2
 RETRY_DELAY = 1  # seconds
+DEFAULT_NO_SPEECH_THRESHOLD = 0.6  # Whisper's own default
+
+
+def _no_speech_threshold(config: dict) -> float:
+    """Mean no_speech_prob above which a transcript is dropped. 1.0 disables."""
+    try:
+        value = float(config.get("no_speech_threshold", DEFAULT_NO_SPEECH_THRESHOLD))
+    except (TypeError, ValueError):
+        return DEFAULT_NO_SPEECH_THRESHOLD
+    return value if 0.0 <= value <= 1.0 else DEFAULT_NO_SPEECH_THRESHOLD
 
 
 class ASRProvider(ASRProviderBase):
@@ -43,6 +53,7 @@ def __init__(self, config: dict, delete_audio_file: bool):
         self.beam_size = int(config.get("beam_size", 1))
         self.cpu_threads = int(config.get("cpu_threads", 0))
         self.initial_prompt = config.get("initial_prompt", None)
+        self.no_speech_threshold = _no_speech_threshold(config)
         self.delete_audio_file = delete_audio_file
 
         if self.output_dir:
@@ -110,6 +121,17 @@ async def speech_to_text(
                 segments = list(segments)
 
                 content = "".join(seg.text for seg in segments).strip()
+                # Near-silence after Dotty stops speaking comes back as a
+                # confident stock phrase ("Thank you."). vad_filter is off, so
+                # Whisper's own no-speech score is the only signal here.
+                if segments and content:
+                    mean_no_speech = sum(s.no_speech_prob for s in segments) / len(segments)
+                    if mean_no_speech > self.no_speech_threshold:
+                        logger.bind(tag=TAG).info(
+                            f"ASR-REJECT no_speech={mean_no_speech:.3f} > "
+                            f"{self.no_speech_threshold:.2f} | dropped {content!r}"
+                        )
+                        content = ""
                 text = {"content": content}
 
                 logger.bind(tag=TAG).info(
diff --git a/custom-providers/pi_voice/README.md b/custom-providers/pi_voice/README.md
index e261fab5..4b0e07ab 100644
--- a/custom-providers/pi_voice/README.md
+++ b/custom-providers/pi_voice/README.md
@@ -168,3 +168,20 @@ Conversation logging and explicit memory writes are implemented by the
 - [`../../dotty-pi-ext/README.md`](../../dotty-pi-ext/README.md) — voice-tool extension.
 - [`../textUtils.py`](../textUtils.py) — the shared `build_turn_suffix` sandwich + emoji map.
 - [#36](https://github.com/BrettKinny/dotty-stackchan/issues/36) — cutover plan + soak rule.
+
+## Dashboard reporting
+
+The bridge dashboard never sees a voice turn on its own (turns go straight
+from this provider to `dotty-pi`), so `PiVoiceLLM` reports each completed
+turn to the bridge at `POST /api/voice/turn`, and each kid-mode filter hit at
+`POST /api/voice/filter-hit`. That feeds the dashboard's Turns tab, error
+toast, Errors count/report and Content filter card.
+
+- Fire-and-forget on a daemon thread with a 2 s timeout; failures are
+  swallowed, so a missing dashboard never delays or breaks a turn.
+- Target: `DOTTY_DASHBOARD_URL` if set, otherwise the host from `BRIDGE_URL`
+  / `VISION_BRIDGE_URL` on port 8081. With none set, reporting is off.
+- Sends `X-Admin-Token` when `DOTTY_ADMIN_TOKEN` is set (the bridge enforces
+  it when its own copy is set).
+- The bridge keeps turns in memory only (last 200); nothing is written to
+  disk and the list empties on a bridge restart.
diff --git a/custom-providers/pi_voice/pi_client.py b/custom-providers/pi_voice/pi_client.py
index 7431bf3e..9b53c452 100644
--- a/custom-providers/pi_voice/pi_client.py
+++ b/custom-providers/pi_voice/pi_client.py
@@ -98,6 +98,7 @@ def local_exec_subprocess_factory(
 
 
 SubprocessFactory = Callable[[], subprocess.Popen]
+VoiceToolRunner = Callable[[str, dict[str, str]], str]
 
 
 class PiClientError(Exception):
@@ -129,6 +130,7 @@ def __init__(
         *,
         turn_timeout_sec: float = 120.0,
         stderr_ring_size: int = 200,
+        voice_tool_runner: VoiceToolRunner | None = None,
     ):
         self._spawn = subprocess_factory
         self._proc: Optional[subprocess.Popen] = None
@@ -141,6 +143,7 @@ def __init__(
         self._turn_timeout_sec = turn_timeout_sec
         self._next_req_id = 0
         self._closed = False
+        self._voice_tool_runner = voice_tool_runner
 
     # ------------------------------------------------------------------
     # lifecycle
@@ -204,7 +207,12 @@ def new_session(self) -> None:
             if (
                 frame.get("type") == "response"
                 and frame.get("command") == "new_session"
+                and frame.get("id") == req_id
             ):
+                if not frame.get("success", False):
+                    raise PiClientError(
+                        f"pi rejected new_session: {frame.get('error', 'unknown')}"
+                    )
                 return
         raise PiClientError("new_session timed out waiting for response")
 
@@ -277,6 +285,15 @@ def iter_turn_text(self, prompt: str) -> Iterator[str]:
             f"turn timed out after {self._turn_timeout_sec}s"
         )
 
+    def invoke_voice_tool(self, name: str, arguments: dict[str, str]) -> str:
+        """Run one deterministic voice tool outside the fallible 4B router."""
+        if self._voice_tool_runner is None:
+            raise PiClientError("direct voice-tool runner is not configured")
+        try:
+            return self._voice_tool_runner(name, arguments)
+        except Exception as exc:
+            raise PiClientError(f"voice tool {name} failed: {exc}") from exc
+
     # ------------------------------------------------------------------
     # diagnostics
     # ------------------------------------------------------------------
@@ -365,9 +382,33 @@ def _read_stderr(self) -> None:
 
 # Convenience factory that wires the env-var-defaults into a
 # PiClient ready to be used by xiaozhi-server.
+DEFAULT_SYSTEM_PROMPT_FILE = "/opt/xiaozhi-esp32-server/personas/pi_voice.md"
+
+
+def _system_prompt_args() -> list[str]:
+    """`--system-prompt <persona>` from DOTTY_PI_SYSTEM_PROMPT_FILE.
+
+    Without it pi uses its built-in coding-assistant prompt, and that identity
+    leaks into spoken replies (#177). A missing or empty file keeps the old
+    behaviour rather than breaking the voice path.
+    """
+    path = os.environ.get("DOTTY_PI_SYSTEM_PROMPT_FILE", DEFAULT_SYSTEM_PROMPT_FILE)
+    try:
+        with open(path, encoding="utf-8") as handle:
+            text = handle.read().strip()
+    except OSError:
+        logger.warning("PiClient: no voice persona at %s; pi default prompt in use", path)
+        return []
+    if not text:
+        logger.warning("PiClient: voice persona %s is empty; pi default prompt in use", path)
+        return []
+    return ["--system-prompt", text]
+
+
 def make_default_pi_client() -> PiClient:
     container = os.environ.get("DOTTY_PI_CONTAINER", "dotty-pi")
     pi_args: list[str] = list(_DEFAULT_PI_FLAGS)
+    pi_args.extend(_system_prompt_args())
     extra = os.environ.get("DOTTY_PI_EXTRA_FLAGS", "").split()
     if extra:
         pi_args.extend(extra)
@@ -375,4 +416,53 @@ def make_default_pi_client() -> PiClient:
         subprocess_factory=lambda: local_exec_subprocess_factory(
             container=container, pi_args=pi_args,
         ),
+        voice_tool_runner=lambda name, arguments: _run_container_voice_tool(
+            container, name, arguments,
+        ),
+    )
+
+
+# think_hard waits on the 27B reasoner, which is not kept resident: a cold
+# load is 30-50 s before generation starts. Its own request timeout is
+# VOICE_THINKER_TIMEOUT (90 s) inside the container; allow a little more here.
+_DIRECT_TOOL_TIMEOUT_SEC = {"think_hard": 105}
+
+
+def _run_container_voice_tool(
+    container: str, name: str, arguments: dict[str, str],
+) -> str:
+    modules = {
+        "remember": ("remember.ts", "runRemember", "fact"),
+        "memory_lookup": ("memory_lookup.ts", "runMemoryLookup", "query"),
+        "think_hard": ("think_hard.ts", "runThinkHard", "question"),
+    }
+    if name not in modules:
+        raise PiClientError(f"unsupported direct voice tool: {name}")
+    module, function, argument = modules[name]
+    script = (
+        'import fs from "node:fs";'
+        f'import {{ {function} }} from "/root/.pi/extensions/dotty-pi-ext/src/tools/{module}";'
+        'const input=JSON.parse(fs.readFileSync(0,"utf8"));'
+        f'const result=await {function}(input[{json.dumps(argument)}]);'
+        'process.stdout.write(JSON.stringify({result}));'
+    )
+    proc = subprocess.run(
+        [
+            "docker", "exec", "-i", container, "node",
+            "--experimental-strip-types", "--input-type=module", "-e", script,
+        ],
+        input=json.dumps(arguments), text=True, capture_output=True,
+        timeout=_DIRECT_TOOL_TIMEOUT_SEC.get(name, 60), check=False,
     )
+    if proc.returncode != 0:
+        raise PiClientError(proc.stderr.strip() or f"tool exited {proc.returncode}")
+    try:
+        payload = json.loads(proc.stdout)
+    except json.JSONDecodeError as exc:
+        raise PiClientError("voice tool returned invalid JSON") from exc
+    if not isinstance(payload, dict):
+        raise PiClientError("voice tool returned invalid JSON shape")
+    result = payload.get("result")
+    if not isinstance(result, str):
+        raise PiClientError("voice tool returned a non-string result")
+    return result
diff --git a/custom-providers/pi_voice/pi_voice.py b/custom-providers/pi_voice/pi_voice.py
index 39036be2..b2bc2c47 100644
--- a/custom-providers/pi_voice/pi_voice.py
+++ b/custom-providers/pi_voice/pi_voice.py
@@ -35,9 +35,14 @@
 
 import json
 import os
+import re
+import threading
+import time
 import unicodedata
+import urllib.request
 from pathlib import Path
 from typing import Iterator
+from urllib.parse import urlparse
 
 from .pi_client import PiClient, PiClientError, make_default_pi_client
 
@@ -104,6 +109,53 @@ def _read_kid_mode() -> bool:
     return os.environ.get("DOTTY_KID_MODE", "true").lower() in ("1", "true", "yes")
 
 
+_DASHBOARD_PORT = 8081
+
+
+def _dashboard_url() -> str:
+    """Base URL of the bridge dashboard, or "" when it can't be worked out.
+
+    `DOTTY_DASHBOARD_URL` wins. Otherwise assume the dashboard sits on the
+    same host as dotty-behaviour (which this container already reaches via
+    `BRIDGE_URL` / `VISION_BRIDGE_URL`) on its default port."""
+    explicit = os.environ.get("DOTTY_DASHBOARD_URL", "").strip()
+    if explicit:
+        return explicit.rstrip("/")
+    sibling = os.environ.get("BRIDGE_URL") or os.environ.get("VISION_BRIDGE_URL", "")
+    parsed = urlparse(sibling)
+    if not parsed.hostname:
+        return ""
+    return f"{parsed.scheme or 'http'}://{parsed.hostname}:{_DASHBOARD_PORT}"
+
+
+def _report_to_dashboard(path: str, payload: dict) -> None:
+    """Fire-and-forget POST to the bridge dashboard.
+
+    Runs on a daemon thread with a short timeout and swallows every error:
+    a missing or slow dashboard must never delay or break a voice turn."""
+    base = _dashboard_url()
+    if not base:
+        return
+    headers = {"Content-Type": "application/json"}
+    token = os.environ.get("DOTTY_ADMIN_TOKEN", "").strip()
+    if token:
+        headers["X-Admin-Token"] = token
+    body = json.dumps(payload).encode("utf-8")
+
+    def _post() -> None:
+        try:
+            req = urllib.request.Request(
+                base + path, data=body, headers=headers, method="POST",
+            )
+            urllib.request.urlopen(req, timeout=2).close()
+        except Exception as exc:
+            logger.debug("PiVoiceLLM dashboard report to %s failed: %s", path, exc)
+
+    threading.Thread(
+        target=_post, name="dotty-dashboard-report", daemon=True,
+    ).start()
+
+
 def _last_user_text(dialogue: list[dict]) -> str:
     """Find the most recent user-turn content. xiaozhi's dialogue is a
     list of {role, content} dicts in chronological order; the last user
@@ -148,6 +200,21 @@ def _normalise_user_content(content: object) -> str:
 )
 
 
+# Appended to the user's words for an explicit recall. dotty-pi-ext's
+# turn_text.ts strips from this exact marker when logging the turn, so search
+# results are never written back into memory as if the person had said them.
+_MEMORY_CONTEXT = (
+    "\n\nMEMORY SEARCH RESULTS (from earlier conversations; \"user\" is the "
+    "person, \"assistant\" was you):\n{results}\n"
+    "Answer their question from these results in your own words. If the "
+    "results do not answer it, say you don't remember that yet. Never read "
+    "the results out as they are written."
+)
+
+
+_THINKING_PREAMBLE = "\U0001F914 Let me think hard about that. "
+
+
 def _wrap_with_sandwich(user_text: str, kid_mode: bool) -> str:
     """Append the HARD CONSTRAINTS suffix to the user's text via the shared
     textUtils.build_turn_suffix contract — emoji-prefix
@@ -201,6 +268,21 @@ def _enforce_leading_emoji(chunks: Iterator[str]) -> Iterator[str]:
         yield f"{FALLBACK_EMOJI} (no response)"
 
 
+_REMEMBER_INTENT_RE = re.compile(
+    r"^\s*(?:please\s+)?remember\s+(?:that\s+)?(?P<fact>.+?)\s*[.!?]?\s*$",
+    re.IGNORECASE,
+)
+_RECALL_INTENT_RE = re.compile(
+    r"^\s*(?:what did i (?:tell|say to) you about|do you remember)\s+"
+    r"(?P<query>.+?)\s*[?!.]?\s*$",
+    re.IGNORECASE,
+)
+_THINK_HARD_INTENT_RE = re.compile(
+    r"^\s*(?:please\s+)?think hard (?:about\s*:?)?\s*(?P<question>.+?)\s*[?!.]?\s*$",
+    re.IGNORECASE,
+)
+
+
 class LLMProvider(LLMProviderBase):
     """xiaozhi-server LLM provider backed by the dotty-pi container."""
 
@@ -214,6 +296,11 @@ def __init__(self, config: dict, *, client: PiClient | None = None):
         # `client` is injected by tests; production passes None to get
         # the env-configured default.
         self._client: PiClient = client if client is not None else make_default_pi_client()
+        # A connection can submit multiple chat jobs to its thread pool. Pi RPC
+        # is one ordered stream, so keep the complete new_session -> prompt ->
+        # agent_end transaction exclusive; per-write locking cannot prevent one
+        # caller from consuming another caller's response frames.
+        self._turn_lock = threading.Lock()
         self._first_turn = True
         msg = f"PiVoiceLLM ready (container={self._container} kid_mode={self._kid_mode})"
         try:
@@ -224,12 +311,78 @@ def __init__(self, config: dict, *, client: PiClient | None = None):
     # xiaozhi-server's voice loop calls this as a sync generator.
     # Each yielded string becomes a TTS chunk.
     def response(self, session_id, dialogue, **kwargs) -> Iterator[str]:
+        with self._turn_lock:
+            yield from self._response_serialized(session_id, dialogue, **kwargs)
+
+    def _response_serialized(self, session_id, dialogue, **kwargs) -> Iterator[str]:
+        """Run one complete Pi RPC transaction while ``_turn_lock`` is held."""
         self._kid_mode = _read_kid_mode()
         user_text = _last_user_text(dialogue)
         if not user_text:
             yield f"{FALLBACK_EMOJI} (empty turn)"
             return
-        prompt = _wrap_with_sandwich(user_text, self._kid_mode)
+        # Everything spoken this turn is reported to the dashboard when the
+        # generator finishes — including when xiaozhi closes it early.
+        spoken: list[str] = []
+        errors: list[str] = []
+        started = time.monotonic()
+        try:
+            for chunk in self._respond(user_text, errors):
+                spoken.append(chunk)
+                yield chunk
+        finally:
+            _report_to_dashboard("/api/voice/turn", {
+                "request_text": user_text,
+                "response_text": "".join(spoken),
+                "latency_ms": int((time.monotonic() - started) * 1000),
+                "error": "; ".join(errors) or None,
+            })
+
+    def _respond(self, user_text: str, errors: list[str]) -> Iterator[str]:
+        """One turn's TTS chunks. Failures are appended to `errors` so
+        response() can report them alongside the spoken fallback."""
+        memory_context = ""
+        remember_intent = _REMEMBER_INTENT_RE.match(user_text)
+        if remember_intent:
+            fact = remember_intent.group("fact").strip()
+            result = self._invoke_voice_tool("remember", {"fact": fact}, errors)
+            if result == "(remembered)":
+                yield f"{FALLBACK_EMOJI} I'll remember that."
+            else:
+                yield f"{FALLBACK_EMOJI} I couldn't save that memory."
+            return
+        recall_intent = _RECALL_INTENT_RE.match(user_text)
+        if recall_intent:
+            query = recall_intent.group("query").strip()
+            result = self._invoke_voice_tool(
+                "memory_lookup", {"query": query}, errors,
+            )
+            if result is None:
+                yield f"{FALLBACK_EMOJI} I couldn't check my memory right now."
+                return
+            if result in ("(no memories found)", "(empty query)"):
+                yield f"{FALLBACK_EMOJI} I don't remember anything about that yet."
+                return
+            # The lookup is deterministic; the wording is not. Search output is
+            # raw stored rows ("user: … | assistant: …"), never fit to be
+            # spoken as-is, so hand it to the model as context for this turn.
+            memory_context = _MEMORY_CONTEXT.format(results=result)
+        think_intent = None if memory_context else _THINK_HARD_INTENT_RE.match(user_text)
+        if think_intent:
+            question = think_intent.group("question").strip()
+            # The reasoner unloads when idle and takes 30-60 s to come back.
+            # Say so first: this chunk carries the turn's one emoji (the
+            # thinking face) and reaches TTS before the wait starts.
+            yield _THINKING_PREAMBLE
+            result = self._invoke_voice_tool(
+                "think_hard", {"question": question}, errors,
+            )
+            if result is None or result.startswith("("):
+                yield "I couldn't finish the deeper reasoning."
+            else:
+                yield result
+            return
+        prompt = _wrap_with_sandwich(user_text + memory_context, self._kid_mode)
 
         # Reset pi state between voice turns. First turn skips this —
         # the freshly-spawned process is already clean.
@@ -254,18 +407,36 @@ def response(self, session_id, dialogue, **kwargs) -> Iterator[str]:
             ):
                 yield chunk
         except PiClientError as exc:
+            errors.append(str(exc) or exc.__class__.__name__)
             logger.error("PiVoiceLLM turn failed: %s", exc)
             for line in self._client.recent_stderr()[-5:]:
                 logger.error("  pi.stderr: %s", line)
             yield f"{FALLBACK_EMOJI} (brain offline — try again in a moment)"
 
+    def _invoke_voice_tool(
+        self, name: str, arguments: dict[str, str],
+        errors: list[str] | None = None,
+    ) -> str | None:
+        try:
+            return self._client.invoke_voice_tool(name, arguments)
+        except PiClientError as exc:
+            logger.error("PiVoiceLLM direct tool %s failed: %s", name, exc)
+            if errors is not None:
+                errors.append(f"{name}: {exc}" if str(exc) else name)
+            return None
+
     def _on_filter_hit(self, tier: str, match) -> None:
-        # Local logging only — the Prometheus counter / safety ring live in
-        # the bridge container, which this provider can't reach.
         logger.warning(
             "PiVoiceLLM content-filter hit tier=%s pattern=%r — turn replaced",
             tier, match.group(),
         )
+        # The Prometheus counter and /ui/safety/recent ring live in the
+        # bridge container; hand the hit over so the dashboard card shows it.
+        _report_to_dashboard("/api/voice/filter-hit", {
+            "tier": tier,
+            "rule": match.group(),
+            "prefix": match.string[:8],
+        })
 
     def close(self) -> None:
         """xiaozhi may call this on shutdown — make sure pi cleans up."""
diff --git a/custom-providers/pi_voice/tests/test_pi_client.py b/custom-providers/pi_voice/tests/test_pi_client.py
index 50e2b5e2..4f48547c 100644
--- a/custom-providers/pi_voice/tests/test_pi_client.py
+++ b/custom-providers/pi_voice/tests/test_pi_client.py
@@ -17,12 +17,14 @@
 import threading
 import time
 import unittest
+from types import SimpleNamespace
+from unittest.mock import patch
 
 # Make the package importable as `pi_voice.*` regardless of cwd.
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, os.path.dirname(HERE))
 
-from pi_client import PiClient, PiClientError  # noqa: E402
+from pi_client import PiClient, PiClientError, _run_container_voice_tool  # noqa: E402
 
 
 class FakePopen:
@@ -156,6 +158,7 @@ def ns_responder():
                     for cmd in fake.stdin_lines:
                         if cmd.get("type") == "new_session":
                             fake.emit({
+                                "id": cmd["id"],
                                 "type": "response", "command": "new_session",
                                 "success": True,
                             })
@@ -172,6 +175,82 @@ def ns_responder():
         finally:
             client.close()
 
+    def test_new_session_ignores_stale_response_until_matching_ack(self):
+        fake = FakePopen()
+        client = make_client(fake)
+        stale_emitted = threading.Event()
+        release_matching = threading.Event()
+        errors: list[BaseException] = []
+
+        def responder():
+            while True:
+                time.sleep(0.01)
+                for cmd in fake.stdin_lines:
+                    if cmd.get("type") == "new_session":
+                        fake.emit({
+                            "id": "nsess-stale",
+                            "type": "response",
+                            "command": "new_session",
+                            "success": False,
+                            "error": "stale failure",
+                        })
+                        stale_emitted.set()
+                        release_matching.wait(timeout=2)
+                        fake.emit({
+                            "id": cmd["id"],
+                            "type": "response",
+                            "command": "new_session",
+                            "success": True,
+                        })
+                        return
+
+        def reset_session():
+            try:
+                client.new_session()
+            except BaseException as exc:  # captured for the main test thread
+                errors.append(exc)
+
+        threading.Thread(target=responder, daemon=True).start()
+        reset = threading.Thread(target=reset_session)
+        reset.start()
+        try:
+            self.assertTrue(stale_emitted.wait(timeout=1))
+            time.sleep(0.05)
+            self.assertTrue(reset.is_alive(), "stale response must not complete reset")
+            release_matching.set()
+            reset.join(timeout=2)
+            self.assertFalse(reset.is_alive())
+            self.assertEqual(errors, [])
+        finally:
+            release_matching.set()
+            reset.join(timeout=2)
+            client.close()
+
+    def test_new_session_raises_on_matching_failure(self):
+        fake = FakePopen()
+        client = make_client(fake)
+
+        def responder():
+            while True:
+                time.sleep(0.01)
+                for cmd in fake.stdin_lines:
+                    if cmd.get("type") == "new_session":
+                        fake.emit({
+                            "id": cmd["id"],
+                            "type": "response",
+                            "command": "new_session",
+                            "success": False,
+                            "error": "reset refused",
+                        })
+                        return
+
+        threading.Thread(target=responder, daemon=True).start()
+        try:
+            with self.assertRaisesRegex(PiClientError, "reset refused"):
+                client.new_session()
+        finally:
+            client.close()
+
 
 class TestThinkingFilter(unittest.TestCase):
     def test_thinking_deltas_are_dropped(self):
@@ -359,5 +438,49 @@ def test_silent_pi_times_out(self):
             client.close()
 
 
+class TestContainerVoiceToolRunner(unittest.TestCase):
+    def test_rejects_tools_outside_allowlist_without_spawning(self):
+        with patch("pi_client.subprocess.run") as run:
+            with self.assertRaisesRegex(PiClientError, "unsupported"):
+                _run_container_voice_tool("dotty-pi", "play_song", {"name": "x"})
+        run.assert_not_called()
+
+    def test_rejects_malformed_json_output(self):
+        completed = SimpleNamespace(returncode=0, stdout="not-json", stderr="")
+        with patch("pi_client.subprocess.run", return_value=completed):
+            with self.assertRaisesRegex(PiClientError, "invalid JSON"):
+                _run_container_voice_tool("dotty-pi", "remember", {"fact": "x"})
+
+    def test_rejects_non_string_result(self):
+        completed = SimpleNamespace(
+            returncode=0, stdout='{"result":42}', stderr="",
+        )
+        with patch("pi_client.subprocess.run", return_value=completed):
+            with self.assertRaisesRegex(PiClientError, "non-string"):
+                _run_container_voice_tool("dotty-pi", "remember", {"fact": "x"})
+
+
+
+class TestDirectToolTimeouts(unittest.TestCase):
+    """think_hard may wait for a cold 27B load; quick tools must stay quick."""
+
+    def _timeout_for(self, name: str, argument: str) -> float:
+        seen = {}
+
+        def fake_run(argv, **kwargs):
+            seen["timeout"] = kwargs["timeout"]
+            return SimpleNamespace(returncode=0, stdout=json.dumps({"result": "ok"}), stderr="")
+
+        with patch("pi_client.subprocess.run", fake_run):
+            _run_container_voice_tool("dotty-pi", name, {argument: "x"})
+        return seen["timeout"]
+
+    def test_think_hard_outlasts_the_reasoner_cold_start(self):
+        self.assertGreaterEqual(self._timeout_for("think_hard", "question"), 100)
+
+    def test_memory_tools_keep_a_short_timeout(self):
+        self.assertEqual(self._timeout_for("memory_lookup", "query"), 60)
+        self.assertEqual(self._timeout_for("remember", "fact"), 60)
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/custom-providers/pi_voice/tests/test_pi_system_prompt.py b/custom-providers/pi_voice/tests/test_pi_system_prompt.py
new file mode 100644
index 00000000..8730c210
--- /dev/null
+++ b/custom-providers/pi_voice/tests/test_pi_system_prompt.py
@@ -0,0 +1,64 @@
+"""The live voice path must give pi a Dotty identity (#177).
+
+AI-assisted (Claude). Without `--system-prompt`, pi falls back to its built-in
+coding-assistant prompt and the robot introduces itself as one.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import pi_client  # noqa: E402
+
+
+def _spawned_args(env: dict[str, str]) -> list[str]:
+    captured: dict[str, list[str]] = {}
+
+    def fake_factory(container, pi_args):
+        captured["args"] = list(pi_args)
+        raise RuntimeError("stop before spawning")
+
+    with patch.dict(os.environ, env, clear=False), \
+         patch.object(pi_client, "local_exec_subprocess_factory", fake_factory):
+        client = pi_client.make_default_pi_client()
+        try:
+            client._spawn()
+        except RuntimeError:
+            pass
+    return captured["args"]
+
+
+class SystemPromptTests(unittest.TestCase):
+    def test_persona_file_is_passed_as_system_prompt(self):
+        with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as handle:
+            handle.write("You are Dotty, a small desktop robot.\n")
+        self.addCleanup(os.unlink, handle.name)
+        args = _spawned_args({"DOTTY_PI_SYSTEM_PROMPT_FILE": handle.name})
+        self.assertIn("--system-prompt", args)
+        self.assertEqual(args[args.index("--system-prompt") + 1],
+                         "You are Dotty, a small desktop robot.")
+
+    def test_missing_or_empty_file_keeps_previous_behaviour(self):
+        args = _spawned_args({"DOTTY_PI_SYSTEM_PROMPT_FILE": "/nonexistent/persona.md"})
+        self.assertNotIn("--system-prompt", args)
+        with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as handle:
+            handle.write("  \n")
+        self.addCleanup(os.unlink, handle.name)
+        self.assertNotIn("--system-prompt",
+                         _spawned_args({"DOTTY_PI_SYSTEM_PROMPT_FILE": handle.name}))
+
+    def test_shipped_voice_persona_names_dotty_and_not_a_coding_assistant(self):
+        repo = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+        text = open(os.path.join(repo, "personas", "pi_voice.md"), encoding="utf-8").read()
+        self.assertIn("You are Dotty", text)
+        self.assertNotIn("[REMEMBER", text)
+        self.assertLess(len(text), 2500)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/custom-providers/pi_voice/tests/test_pi_voice.py b/custom-providers/pi_voice/tests/test_pi_voice.py
index 7725fa73..13dae2e0 100644
--- a/custom-providers/pi_voice/tests/test_pi_voice.py
+++ b/custom-providers/pi_voice/tests/test_pi_voice.py
@@ -10,6 +10,8 @@
 import os
 import sys
 import tempfile
+import threading
+import time
 import unittest
 from pathlib import Path
 from typing import Iterator
@@ -44,6 +46,9 @@ def __init__(self):
         self.scripted_chunks: list[list[str]] = []
         self.scripted_errors: list[BaseException | None] = []
         self.closed = False
+        self.tool_calls: list[tuple[str, dict[str, str]]] = []
+        self.tool_results: dict[str, str] = {}
+        self.tool_errors: dict[str, BaseException] = {}
 
     def script_turn(self, chunks: list[str], error: BaseException | None = None) -> None:
         self.scripted_chunks.append(chunks)
@@ -64,6 +69,12 @@ def iter_turn_text(self, prompt: str) -> Iterator[str]:
     def recent_stderr(self) -> list[str]:
         return []
 
+    def invoke_voice_tool(self, name: str, arguments: dict[str, str]) -> str:
+        self.tool_calls.append((name, arguments))
+        if name in self.tool_errors:
+            raise self.tool_errors[name]
+        return self.tool_results.get(name, "(tool failed)")
+
     def close(self) -> None:
         self.closed = True
 
@@ -193,6 +204,54 @@ def test_first_turn_skips_new_session(self):
         list(provider.response("s", [{"role": "user", "content": "b"}]))
         self.assertEqual(client.new_session_calls, 1, "new_session on second turn")
 
+    def test_concurrent_responses_are_serialized_through_agent_end(self):
+        class OverlapDetectingClient(FakeClient):
+            def __init__(self):
+                super().__init__()
+                self.active = 0
+                self.max_active = 0
+                self.first_started = threading.Event()
+                self.release_first = threading.Event()
+
+            def iter_turn_text(self, prompt: str) -> Iterator[str]:
+                self.prompts.append(prompt)
+                self.active += 1
+                self.max_active = max(self.max_active, self.active)
+                try:
+                    if len(self.prompts) == 1:
+                        self.first_started.set()
+                        self.release_first.wait(timeout=2)
+                    yield "😊 ok"
+                finally:
+                    self.active -= 1
+
+        os.environ["DOTTY_KID_MODE"] = "false"
+        client = OverlapDetectingClient()
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        outputs: list[list[str]] = []
+
+        def run(text: str) -> None:
+            outputs.append(list(provider.response(
+                "s", [{"role": "user", "content": text}],
+            )))
+
+        first = threading.Thread(target=run, args=("first",))
+        second = threading.Thread(target=run, args=("second",))
+        first.start()
+        self.assertTrue(client.first_started.wait(timeout=1))
+        second.start()
+        time.sleep(0.05)
+        self.assertEqual(len(client.prompts), 1, "second turn must wait")
+        client.release_first.set()
+        first.join(timeout=2)
+        second.join(timeout=2)
+
+        self.assertFalse(first.is_alive())
+        self.assertFalse(second.is_alive())
+        self.assertEqual(client.max_active, 1)
+        self.assertEqual(len(outputs), 2)
+        self.assertEqual(client.new_session_calls, 1)
+
 
 class TestErrorFallback(unittest.TestCase):
     def test_client_error_yields_fallback(self):
@@ -204,6 +263,126 @@ def test_client_error_yields_fallback(self):
         self.assertEqual(out, [f"{textUtils.FALLBACK_EMOJI} (brain offline — try again in a moment)"])
 
 
+class TestDeterministicVoiceToolRouting(unittest.TestCase):
+    def test_explicit_remember_invokes_tool_and_never_claims_failed_write(self):
+        client = FakeClient()
+        client.tool_results["remember"] = "(remember failed)"
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "Remember that my calibration color is ultraviolet"}],
+        ))
+
+        self.assertEqual(
+            client.tool_calls,
+            [("remember", {"fact": "my calibration color is ultraviolet"})],
+        )
+        self.assertNotIn("remembered", out.lower())
+        self.assertIn("couldn't save", out.lower())
+
+    def test_remember_client_error_returns_honest_tts_failure(self):
+        client = FakeClient()
+        client.tool_errors["remember"] = PiClientError("tool timed out")
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "Remember that the key is amber"}],
+        ))
+
+        self.assertEqual(out, f"{textUtils.FALLBACK_EMOJI} I couldn't save that memory.")
+
+    def test_explicit_recall_looks_up_then_lets_the_model_phrase_the_answer(self):
+        # Raw rows ("user: … | assistant: …") are search output, not speech:
+        # the lookup stays deterministic, the wording comes from the model.
+        client = FakeClient()
+        client.tool_results["memory_lookup"] = (
+            "user: My calibration color is ultraviolet. | assistant: 😊 Noted!"
+        )
+        client.script_turn(["😊 You told me it is ultraviolet."])
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "What did I tell you about my calibration color?"}],
+        ))
+
+        self.assertEqual(
+            client.tool_calls,
+            [("memory_lookup", {"query": "my calibration color"})],
+        )
+        self.assertEqual(out, "😊 You told me it is ultraviolet.")
+        self.assertNotIn("assistant:", out)
+        self.assertEqual(len(client.prompts), 1)
+        prompt = client.prompts[0]
+        self.assertTrue(prompt.startswith(
+            "What did I tell you about my calibration color?\n\nMEMORY SEARCH RESULTS ("))
+        self.assertIn("My calibration color is ultraviolet.", prompt)
+        self.assertLess(prompt.index("MEMORY SEARCH RESULTS"), prompt.index("HARD CONSTRAINTS"))
+
+    def test_recall_with_no_matches_does_not_spend_a_model_turn(self):
+        client = FakeClient()
+        client.tool_results["memory_lookup"] = "(no memories found)"
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "Do you remember my calibration color?"}],
+        ))
+
+        self.assertEqual(
+            out, f"{textUtils.FALLBACK_EMOJI} I don't remember anything about that yet.",
+        )
+        self.assertEqual(client.prompts, [])
+
+    def test_recall_client_error_returns_honest_tts_failure(self):
+        client = FakeClient()
+        client.tool_errors["memory_lookup"] = PiClientError("lookup failed")
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "Do you remember my calibration color?"}],
+        ))
+
+        self.assertEqual(
+            out, f"{textUtils.FALLBACK_EMOJI} I couldn't check my memory right now.",
+        )
+
+    def test_explicit_think_hard_speaks_first_then_answers_with_one_emoji(self):
+        # The reasoner can take 30-60 s to load from cold. Dotty says so before
+        # starting instead of sitting silent, and the reply still carries
+        # exactly one (leading) emoji.
+        client = FakeClient()
+        client.tool_results["think_hard"] = "The precise answer is forty-two."
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        turn = provider.response(
+            "s", [{"role": "user", "content": "Think hard about: what is six times seven?"}],
+        )
+        first = next(turn)
+        self.assertEqual(first, "🤔 Let me think hard about that. ")
+        self.assertEqual(client.tool_calls, [])          # nothing started before Dotty spoke
+        rest = "".join(turn)
+
+        self.assertEqual(
+            client.tool_calls,
+            [("think_hard", {"question": "what is six times seven"})],
+        )
+        self.assertEqual(rest, "The precise answer is forty-two.")
+        emojis = [ch for ch in first + rest if ch in textUtils.ALLOWED_EMOJIS]
+        self.assertEqual(emojis, ["🤔"])
+
+    def test_think_hard_client_timeout_returns_honest_tts_failure(self):
+        client = FakeClient()
+        client.tool_errors["think_hard"] = PiClientError("tool timed out")
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "Think hard about: six times seven"}],
+        ))
+
+        self.assertEqual(
+            out, "🤔 Let me think hard about that. I couldn't finish the deeper reasoning.",
+        )
+
+
 class TestLeadingEmojiContract(unittest.TestCase):
     def _response(self, chunks: list[str], *, kid_mode: bool = False) -> list[str]:
         env = {
@@ -247,5 +426,121 @@ def test_kid_filter_still_replaces_the_complete_turn(self):
         self.assertEqual(out, [textUtils.CONTENT_FILTER_REPLACEMENT])
 
 
+class TestDashboardReporting(unittest.TestCase):
+    """Each turn (and each kid-filter hit) is reported to the bridge
+    dashboard, which otherwise never sees a voice turn."""
+
+    def setUp(self):
+        import pi_voice.pi_voice as mod
+        self.mod = mod
+        self.reports: list[tuple[str, dict]] = []
+        p = patch.object(mod, "_report_to_dashboard",
+                         lambda path, payload: self.reports.append((path, payload)))
+        p.start()
+        self.addCleanup(p.stop)
+
+    def _turns(self):
+        return [body for path, body in self.reports if path == "/api/voice/turn"]
+
+    def test_successful_turn_is_reported(self):
+        os.environ["DOTTY_KID_MODE"] = "false"
+        client = FakeClient()
+        client.script_turn(["😊 ", "Hi there"])
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        out = "".join(provider.response("s", [{"role": "user", "content": "Hello"}]))
+        (turn,) = self._turns()
+        self.assertEqual(turn["request_text"], "Hello")
+        self.assertEqual(turn["response_text"], out)
+        self.assertIsNone(turn["error"])
+        self.assertGreaterEqual(turn["latency_ms"], 0)
+
+    def test_failed_turn_is_reported_with_error(self):
+        client = FakeClient()
+        client.script_turn([], error=PiClientError("rpc timeout"))
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        list(provider.response("s", [{"role": "user", "content": "Hello"}]))
+        (turn,) = self._turns()
+        self.assertEqual(turn["error"], "rpc timeout")
+        self.assertIn("brain offline", turn["response_text"])
+
+    def test_early_close_still_reports(self):
+        os.environ["DOTTY_KID_MODE"] = "false"
+        client = FakeClient()
+        client.script_turn(["😊 one ", "two ", "three"])
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        gen = provider.response("s", [{"role": "user", "content": "Hello"}])
+        first = next(gen)
+        gen.close()
+        (turn,) = self._turns()
+        self.assertEqual(turn["response_text"], first)
+
+    def test_direct_tool_turn_is_reported(self):
+        client = FakeClient()
+        client.tool_results["remember"] = "(remembered)"
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        out = "".join(provider.response(
+            "s", [{"role": "user", "content": "remember that my cat is called Biscuit"}],
+        ))
+        (turn,) = self._turns()
+        self.assertEqual(turn["request_text"], "remember that my cat is called Biscuit")
+        self.assertEqual(turn["response_text"], out)
+        self.assertIsNone(turn["error"])
+
+    def test_direct_tool_failure_is_reported_with_error(self):
+        client = FakeClient()
+        client.tool_errors["think_hard"] = PiClientError("tool timed out")
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        list(provider.response(
+            "s", [{"role": "user", "content": "think hard about why the sky is blue"}],
+        ))
+        (turn,) = self._turns()
+        self.assertEqual(turn["error"], "think_hard: tool timed out")
+        self.assertIn("couldn't finish", turn["response_text"])
+
+    def test_empty_turn_is_not_reported(self):
+        provider = LLMProvider({}, client=FakeClient())  # type: ignore[arg-type]
+        list(provider.response("s", [{"role": "assistant", "content": "x"}]))
+        self.assertEqual(self.reports, [])
+
+    def test_filter_hit_is_reported_without_blocked_reply(self):
+        os.environ["DOTTY_KID_MODE"] = "true"
+        client = FakeClient()
+        client.script_turn(["😊 that is a load of shit"])
+        provider = LLMProvider({}, client=client)  # type: ignore[arg-type]
+        with tempfile.TemporaryDirectory() as d, patch.dict(
+            os.environ, {"DOTTY_KID_MODE_STATE": str(Path(d) / "missing")},
+        ):
+            out = "".join(provider.response("s", [{"role": "user", "content": "Hello"}]))
+        hits = [body for path, body in self.reports if path == "/api/voice/filter-hit"]
+        self.assertEqual(len(hits), 1)
+        self.assertEqual(hits[0]["rule"], "shit")
+        (turn,) = self._turns()
+        self.assertEqual(turn["response_text"], out)
+        self.assertNotIn("shit", turn["response_text"])
+
+
+class TestDashboardUrl(unittest.TestCase):
+    def _url(self, env: dict) -> str:
+        import pi_voice.pi_voice as mod
+        clean = {k: v for k, v in os.environ.items()
+                 if k not in ("DOTTY_DASHBOARD_URL", "BRIDGE_URL", "VISION_BRIDGE_URL")}
+        with patch.dict(os.environ, {**clean, **env}, clear=True):
+            return mod._dashboard_url()
+
+    def test_explicit_url_wins(self):
+        self.assertEqual(
+            self._url({"DOTTY_DASHBOARD_URL": "http://dash:9000/",
+                       "VISION_BRIDGE_URL": "http://10.0.0.5:8090"}),
+            "http://dash:9000",
+        )
+
+    def test_derived_from_behaviour_host(self):
+        self.assertEqual(self._url({"VISION_BRIDGE_URL": "http://10.0.0.5:8090"}),
+                         "http://10.0.0.5:8081")
+
+    def test_unknown_host_disables_reporting(self):
+        self.assertEqual(self._url({}), "")
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/custom-providers/xiaozhi-patches/http_server.py b/custom-providers/xiaozhi-patches/http_server.py
index b71585e0..d1e3dbca 100644
--- a/custom-providers/xiaozhi-patches/http_server.py
+++ b/custom-providers/xiaozhi-patches/http_server.py
@@ -552,16 +552,18 @@ async def _dotty_say(self, request: "web.Request") -> "web.Response":
         )
 
         sentence_id = _uuid.uuid4().hex
+        server_push_ids = getattr(conn, "_dotty_server_push_sentence_ids", None)
+        if server_push_ids is None:
+            server_push_ids = set()
+            conn._dotty_server_push_sentence_ids = server_push_ids
 
         def _enqueue() -> None:
             try:
-                # The consumer thread filters with
-                # `message.sentence_id != self.conn.sentence_id` and
-                # drops anything that doesn't match — so we stamp the
-                # conn with our new id BEFORE putting messages on the
-                # queue. This will pre-empt any in-flight TTS for this
-                # conn, which is acceptable for server-pushed greetings
-                # (they shouldn't race a chat turn in normal operation).
+                # Stamp the connection so an idle device treats this as its
+                # active utterance. Explicitly register this ID as a server
+                # push so the patched TTS consumer accepts it independently
+                # if a concurrent chat replaces conn.sentence_id (#104).
+                server_push_ids.add(sentence_id)
                 #
                 # Frame the utterance with FIRST/MIDDLE/LAST: FIRST inits
                 # consumer state, MIDDLE carries the text into the
@@ -589,6 +591,12 @@ def _enqueue() -> None:
         # The puts are sync on a thread-safe queue, but we hop a thread
         # so the aiohttp loop never blocks on producer-side contention.
         await asyncio.to_thread(_enqueue)
+        # Consumers need the marker through text synthesis and audio queuing,
+        # but not forever. Expiry bounds per-connection state without risking
+        # eviction of an active push during a short burst.
+        asyncio.get_running_loop().call_later(
+            120.0, server_push_ids.discard, sentence_id,
+        )
         self.logger.bind(tag=TAG).info(
             f"say queued device={resolved_id} sid={sentence_id[:8]} "
             f"text={text[:60]!r}"
diff --git a/docs/about.md b/docs/about.md
index 848a985d..7210de1a 100644
--- a/docs/about.md
+++ b/docs/about.md
@@ -48,7 +48,7 @@ This is a hackable starting point, not a product. There are no releases, no inst
 
 - A polished end-user product. No GUI installer, no app store, no firmware OTA distribution.
 - Multi-user / multi-device. The reference deployment is one robot talking to one server.
-- Upstream firmware development. We build from `m5stack/StackChan` source but don't maintain firmware patches beyond what's needed for the voice integration.
+- General upstream firmware development. Dotty builds from the pinned `BrettKinny/StackChan@dotty` fork of `m5stack/StackChan` and maintains the state, motion, LED, privacy, and perception changes needed by this stack.
 - Cloud hosting. This is designed for a LAN deployment. You could expose it to the internet, but that's your problem.
 
 ## Privacy
diff --git a/docs/architecture.md b/docs/architecture.md
index a701575b..10d8826e 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -61,7 +61,7 @@ Solid arrows are per-turn data flow; dotted arrows are cloud / conditional. All
 
 | Actor | Host | Role | Process |
 |---|---|---|---|
-| **StackChan** | Desk | Captures audio, plays audio, renders face, runs MCP tools for head/LED/camera | ESP32-S3 firmware built from `m5stack/StackChan` |
+| **StackChan** | Desk | Captures audio, plays audio, renders face, runs MCP tools for head/LED/camera | ESP32-S3 firmware built from the pinned `BrettKinny/StackChan@dotty` fork |
 | **xiaozhi-esp32-server** | Docker host | VAD → ASR → LLM (proxy) → TTS pipeline, emotion dispatch, OTA, admin surface | Docker container |
 | **PiVoiceLLM custom provider** | Docker host (inside xiaozhi container) | Default LLM provider — translates each voice turn into a pi RPC request, streams TTS-bound text back | Python, mounted via volume |
 | **dotty-pi** | Docker host | The voice-tool brain — pi coding agent with the `dotty-pi-ext` extension; owns the agent loop and tool dispatch | Docker container (`dotty-pi`) |
@@ -208,7 +208,7 @@ The xiaozhi-server's `EventTextMessageHandler` (`custom-providers/xiaozhi-patche
 | Consumer | What it does |
 |---|---|
 | `FaceGreeter` | "Hi!" greeting (via `/xiaozhi/admin/inject-text`) on first face detection after a cooldown window. |
-| `SoundTurner` | Head-turn (via `/xiaozhi/admin/set-head-angles`) toward sound direction. |
+| `SoundTurner` | Head-turn (via `/xiaozhi/admin/set-head-angles`) toward sound direction. **Off by default** (`SOUND_TURN_ENABLED=0`) — the firmware localizer is stuck-left (#27), so it only ever turned left. |
 | `FaceLostAborter` | Aborts an in-flight TTS turn (via `/xiaozhi/admin/abort`) when the audience walks away. |
 | `WakeWordTurner` | Head-turn toward the speaker on wake-word event. |
 | `FaceIdentifiedRefresher` | Re-asserts the face-identified pixel every ~3 s so the firmware's 4 s timeout doesn't drop it. |
diff --git a/docs/bench-runbook.md b/docs/bench-runbook.md
index 0d118842..8a477bcc 100644
--- a/docs/bench-runbook.md
+++ b/docs/bench-runbook.md
@@ -130,14 +130,17 @@ directly in this file on a branch). Every check gets `PASS` / `FAIL` /
 
 | ID | Brett does | Eyes / video | Logs (Claude) |
 |---|---|---|---|
-| I1 | Voice: *"goodnight Dotty"* | Smooth face-down travel (~3–4 s), pixel 0 very dim blue, sleepy emoji + `Zzz…` bubble, audible torque-release click ~1 s after settle | `state_changed` → `sleep` |
-| I2 | Observe asleep, lights on | Gentle physical droop forward of commanded pose (expected — torque off) | — |
-| I3 | While asleep, idle ~30 s | Idle motion does **NOT** fire | no idle-motion servo commands |
-| I4 | Voice: *"wake up"* | Torque audibly re-engages **first**, wake-tilt up to ~70 pitch, neutral face, pixel 0 off (IDLE) | `state_changed` → `idle` |
-| I5 | *"goodnight Dotty"* again; then **touch the head** | Same wake sequence, lands in IDLE (not TALK) | `head_pet_started` event |
-| I6 | Sleep again; then **walk into camera** | Wakes straight to TALK (pixel 0 cyan); lookAt overrides wake-pose — reads as "looks up, then at you" | `face_detected` → TALK |
+| I1 | Voice: *"goodnight Dotty"* | Neutral home pose; left arc very dim blue, sleepy emoji + `Zzz…`; torque released after settling or the 3 s fallback | `state_changed` → `sleep`; privacy gate engaged, face detector and voice/wake-word processing disabled |
+| I2 | Observe asleep, lights on | Parked and quiet; torque off may allow physical drift, not a commanded face-down pose | — |
+| I3 | While asleep, idle ~30 s | Idle motion does **NOT** fire; listening indicator stays off | no idle-motion servo commands or new face/listening producer activity after sleep settles |
+| I4 | While asleep, say the configured wake word and *"wake up"* | Remains asleep: no listening or wake tilt | no wake detection or sleep-exit transition attributable to speech |
+| I5 | While asleep, briefly **touch the head** | Torque re-engages before wake tilt, neutral face; initial transition to IDLE. A continued ≥2 s hold separately requests listening | `head_pet_started`, then `state_changed` → `idle`; later face/listening transitions are separate |
+| I6 | Sleep again; then **walk into camera view** | Remains asleep; face detection cannot wake privacy sleep | no new face-driven sleep-exit transition |
 | I7 | With Dotty awake: pet the head | NO state change; existing pet behaviours (hearts + happy) still fire | no `state_changed` |
 | I8 | Awake: provoke a "sleepy" emotion reply (😴) | Legacy hard-sleep path still works (face detector off, modifiers removed) | — |
+| I9 | While asleep, explicitly select **idle** in the dashboard | Torque re-engages before wake tilt; `Zzz…` clears, normal perception resumes | admin `set-state` acknowledgement plus `state_changed` → `idle`; not an acoustic test |
+
+Sleep expectations above follow active firmware `3140f03` (source audit 2026-09-12), not the historical face/voice-wake descriptions. See [modes.md](./modes.md#wake-from-sleep-edges) for the privacy gate and release-pin caveat. This correction is AI-assisted (OpenAI Codex, GPT-6); these rows are test instructions, not recorded passes.
 
 ## Phase J — dance + combined indicators — #44
 
diff --git a/docs/dotty-av-tests.md b/docs/dotty-av-tests.md
index 9cb57ecc..06e86f87 100644
--- a/docs/dotty-av-tests.md
+++ b/docs/dotty-av-tests.md
@@ -88,8 +88,80 @@ recordings; they cannot drive Dotty's microphone during a live test.
 DOTTY_AV_VOLUME=25 scripts/dotty-av-test.sh speaker-test
 DOTTY_AV_RESPONSE_SECONDS=30 scripts/dotty-av-test.sh run "Hi E S P. Tell me a joke."
 DOTTY_AV_OUT_DIR=/tmp/dotty-tests scripts/dotty-av-test.sh record 10
+# Optional diagnostic: same capture process also writes diagnostic.capture.wav.
+DOTTY_AV_LOSSLESS_AUDIO=1 scripts/dotty-av-test.sh record 10 /tmp/diagnostic.mp4
 ```
 
 Device selection can be overridden with `DOTTY_AV_VIDEO_DEVICE`,
 `DOTTY_AV_AUDIO_DEVICE`, and `DOTTY_AV_SINK`. The defaults match the C920 and
 the current default PipeWire speaker sink.
+
+`DOTTY_AV_LOSSLESS_AUDIO=1` adds a 32 kHz stereo `pcm_f32le` WAV named from
+the unique MP4 destination (`raw.mp4` → `raw.capture.wav`). Both outputs map the
+same audio input in one FFmpeg process and have the same bounded duration;
+existing MP4s or sidecars are refused. The default remains MP4-only. With the
+Pulse backend, this opt-in also requests float input instead of Pulse's default
+16-bit input format, so above-full-scale samples can survive into the WAV. The
+ALSA fallback retains its existing input format and converts that captured
+signal to float for storage. The input-codec selection follows
+[FFmpeg's Pulse demuxer](https://github.com/FFmpeg/FFmpeg/blob/master/libavdevice/pulse_audio_dec.c).
+
+This is a capture-quality diagnostic, not proof of analogue microphone
+clipping. AAC decoding can create overshoots; the same-input PCM provides an
+independent comparison before AAC encoding, but does not undo clipping or gain
+earlier in the audio stack. MP4 and WAV start timestamps need not align exactly:
+the WAV starts at its first audio sample, and the recording-launch timestamp
+precedes device startup. Do not use matching nominal durations as proof of
+sample-accurate timing.
+
+The overnight evaluator records native-channel prompt and response window
+metrics separately under `native_audio_windows`, including the sidecar when
+present. Prompt metrics include pre-roll and use the approximate playback-end
+anchor; response metrics start after the existing tail margin. These windows
+do not downmix or normalize and do not automatically pass an interaction.
+For follow-up or state-command cases that must start with an open microphone,
+set `require_warm_listening: true` on the case. An absent/stale listening signal
+blocks playback; it does not change the robot's state. The default retains the
+existing `ready_for_followup` prerequisite, except for explicit cold-wake tests.
+
+## Unattended runs
+
+By default a warm case never changes the robot to satisfy its prerequisite: a
+stale or closed-microphone status blocks the case, and a blocked case is not
+retried. After one case the listening status is already older than the 30 s
+limit, so an unattended session needs an explicit opener:
+
+```bash
+scripts/dotty_overnight.py init --session uat-sessions/$(date +%F)/overnight \
+  --host user@docker-host --mic-opener admin_say
+```
+
+With `mic_opener: admin_say` the runner asks `/xiaozhi/admin/say` to make the
+robot say "Ready."; the firmware then opens the microphone. The runner waits
+until the microphone has been open 4–14 s before playing the prompt, and
+records `mic_opened_by` in the result. Playing the wake word through speakers
+proved placement-sensitive on the bench and is not used for this.
+
+Use pre-rendered natural-voice prompts (`prompt_wavs` in the session
+`config.json`, bound to the exact text and a SHA-256). The harness default
+`espeak-ng` voice was mis-transcribed by Whisper even from the reference
+microphone; Piper prompts were recognised 17 times out of 18.
+
+Evidence rules worth knowing when reading results:
+
+- `playback` passes on the reference-microphone transcript **or** on the
+  robot's own recognition of the prompt (`playback_evidence` says which).
+- If the reference microphone mishears a reply whose service TTS text does
+  contain the expected words, the case is `INCONCLUSIVE`
+  (`response_transcript_disagrees_with_tts`), not a failure. Service text never
+  passes a case by itself.
+- Any other recognised speech inside the capture makes the case
+  `INCONCLUSIVE` (`extra_speech_in_capture`): keep the room quiet.
+- Inconclusive attempts reset a case's pass streak but do not count toward
+  quarantine or the three-failure pause.
+
+*Unattended-run additions were AI-assisted by Claude (Opus 5.5) from a
+supervised bench session on 2026-10-05.*
+
+*Lossless capture and window-metrics additions were AI-assisted by OpenAI Codex
+(GPT-6); their automated checks use synthetic audio, not a physical calibration.*
diff --git a/docs/dotty-overnight-clips.md b/docs/dotty-overnight-clips.md
new file mode 100644
index 00000000..633c9a38
--- /dev/null
+++ b/docs/dotty-overnight-clips.md
@@ -0,0 +1,50 @@
+# Local overnight clip review
+
+AI-assisted implementation and documentation: OpenAI Codex (GPT-6). Human review
+is required before publication. This helper never uploads or plays recordings.
+
+Export an interesting completed case using source-video seconds. Retain the
+spoken question and complete response when selecting a window:
+
+```bash
+python scripts/dotty_av_clips.py export uat-sessions/DATE/SESSION CASE_ID --start 0 --end 35 --title 'Dotty gives a tiny performance review'
+python scripts/dotty_av_clips.py index uat-sessions/DATE/SESSION
+```
+
+The first command prints the new export directory. The second prints a local HTML
+review index; each export also contains its own `index.html`. Every index is a new
+snapshot. Original evidence is preserved; existing export names cannot be reused.
+Partial failed exports are retained with `export_state: incomplete` in their
+manifest, and should be retried under a new name.
+
+Each export contains a fitted portrait 1080×1920 `clean.mp4`, a thumbnail, a
+provenance manifest and, when local transcription and its capture offset are
+available, a provisional `captions.srt`. Captions describe the response only;
+the spoken prompt remains in the original audio. All source pixels are retained
+within the portrait frame. The export normalizes original sound; it does not
+replace the soundtrack. Captions are a sidecar, not burned into the clean video.
+
+`manifest.json` records the source recording hash, exact source interval, full case
+timestamp (safe across midnight), code commit, case verdict and caption alignment.
+The review index links back to the uncut source and original result. A passing
+automated test never automatically becomes a promotional recommendation.
+
+Exports default to `clips/needs-review/`. Failed cases go to `clips/failures/`,
+even when reviewed. Inspect these five independent gates before placing an export
+in `clips/ready-for-review/`:
+
+- `visual`: framing, motion and the full interaction are intelligible.
+- `privacy`: faces, household information and spoken personal details are cleared.
+- `captions`: transcription and timing were checked, or omission was intentional.
+- `music`: any music or third-party audio is cleared for the intended use.
+- `context`: the trim and suggested title honestly represent the observed result.
+
+For a new export after those checks, repeat `--reviewed GATE` for each gate.
+That acknowledges review; the helper does not independently prove these facts.
+Ready-for-review still means a human makes the final posting decision. Keep the
+session outside public web hosting and version control; recordings stay local.
+
+Dependencies: Python 3.11+, FFmpeg with libx264, and ffprobe. This tool consumes
+existing `cases/CASE_ID/{raw.mp4,result.json,response.json}` artifacts and never
+runs transcription models itself. `response.json` times are relative to the
+response audio; `result.json.response_offset` locates that audio within `raw.mp4`.
diff --git a/docs/dotty-overnight-coverage.md b/docs/dotty-overnight-coverage.md
new file mode 100644
index 00000000..9bb0901e
--- /dev/null
+++ b/docs/dotty-overnight-coverage.md
@@ -0,0 +1,190 @@
+# Overnight behaviour coverage catalogue
+
+AI-assisted: OpenAI Codex (GPT-6), under Brett's direction. Inventory date:
+2026-09-12. This is a test specification, **not a report of passing tests**.
+Attach actual attempt IDs, deployed versions, verdicts and artifacts in the
+session's coverage/results files. All rows begin `PENDING` unless their stated
+prerequisite makes them `BLOCKED` or a deployed capability is absent.
+
+## Evidence and corrected contracts
+
+Evidence classes: **A** = workstation speaker → physical robot → independently
+recorded microphone audio; **V** = webcam observation; **D** = intended dashboard,
+admin or MCP interface; **P** = physical stimulus such as touch or a real face;
+**S** = isolated fixture or explicitly labelled synthetic event. S proves the
+downstream software branch, never the physical sensor or acoustic route.
+
+For speech, require a continuous decoded microphone track, heard prompt, matching
+robot ASR, independent response transcription, TTS completion and a successful
+next turn. Container logs, nonempty audio metadata or audible workstation prompts
+alone are insufficient. A generic reply matcher cannot validate a tool call,
+screen expression, head motion, music playback or reminder delivery.
+
+Current session findings override these specific stale statements in
+[modes.md](modes.md); preserve the distinction between observed deployment and
+source defaults:
+
+- The deployed `close_connection_no_voice_time=86400` intentionally permits a
+  conversation to remain listening. Ordinary-turn recovery means speech ended,
+  the expected conversational state is healthy, and another utterance works.
+  Do not impose a 20-second transition to idle on that configuration. Separately
+  test deliberate standby/disconnection and the next cold wake. Record whether
+  each attempt started already listening; a wake phrase during an open session
+  does not prove wake-word detection.
+- Active firmware privacy sleep disables face detection, wake-word detection and
+  voice processing. It parks at home `(yaw=0, pitch=0)`, releases torque after
+  settling (3-second fallback), clears listening, and displays Sleepy/Zzz.
+  **Touch or dashboard state change wakes it. Voice and faces must not.** The
+  server's recognized `wake up` phrase cannot bypass a disabled microphone.
+- Active firmware `setState(current)` emits `state_changed` for resynchronization,
+  although entry/exit effects run only on a real transition.
+- `SecurityCycle` has an implemented, default-enabled consumer and is constructed
+  by `dotty-behaviour/main.py`. Verify its actual deployed legs; do not label the
+  entire security backend unimplemented. The current xiaozhi admin router lacks
+  `capture-audio`; audio degradation is a distinct capability gap.
+- Scene synthesis deterministically combines fresh caches; it makes no narrative
+  LLM call. Dreams, dance reflections and proactive greetings use narrative calls.
+- The pi extension registers seven tools. They are separate from firmware MCP
+  tools; registration on the device does not make a tool callable by PiVoiceLLM.
+  `docs/mcp-tools-capture.json` is historical (13 entries including an older
+  privacy-state tool), not the current 15-tool contract.
+
+Source inventory uses this repository and the active development checkout
+`<STACKCHAN_FW_CHECKOUT>`, particularly `firmware/main/hal/hal_mcp.cpp`,
+`firmware/main/stackchan/modes/state_manager.cpp` and upstream `mcp_server.cc`.
+Record the flashed firmware identity before treating those source contracts as
+the deployed implementation. Do not alter the release submodule to run tests.
+
+## Conversation and seven pi tools
+
+| ID | Feature and stimulus | Evidence / required assertions | Cleanup or limitation |
+|---|---|---|---|
+| C01 | Cold wake, then identity | A+V; known standby before wake; wake edge precedes ASR; correct identity spoken completely; screen/LED change; next turn works | Ten consecutive passes for accepted wake baseline; distinguish warm conversation |
+| C02 | Repeat five distinctive words, numbers and a name | A; one ASR turn contains requested meaning; response window contains requested words; no prompt bleed or old response | Use invented/public facts; three consecutive passes |
+| C03 | Arithmetic and constrained short answer | A; independently correct answer and requested length, not merely any speech | Include digit/word alternatives; reject substring matches |
+| C04 | Two-turn context and third unrelated question | A; second answer uses first-turn context; unrelated question does not repeat prior text | Record all turns and actual session boundary |
+| C05 | Short joke, tiny performance review, sleepy-toaster explanation | A+V; coherent relevant reply, requested brevity, expression and audible ending | Good clip candidates; human/agent semantic review required |
+| C06 | Interrupt ongoing speech acoustically, then ask a new question | A+V; actual abort/barge-in, old audio stops, new turn answered, no delayed old answer | Admin abort is a separate D test, not an acoustic substitute |
+| C07 | Quiet open conversation, deliberate standby, then cold wake | A+D; apply configuration-specific resting contract; next turn works in both paths | Do not change 86400-second timeout to satisfy the test |
+| T01 | `memory_lookup`: ask for session-specific invented fact | A+S; actual tool invocation/results; spoken answer agrees with approved fixture; empty query/no match degrade honestly | FTS excludes `person_pending:*`; inspect fixture isolation first |
+| T02 | `remember`: store then retrieve an invented generic fact | A+S; write succeeds in voice namespace; lookup after new turn/process returns it; no false success on DB error | Record exact test row IDs; remove only those rows, never restore whole DB |
+| T03 | `recall_person`: known fixture adult, unknown person, pending minor fact | A+S; approved `person:<id>` only; pending facts absent from both person recall and generic lookup | Use fabricated identities in isolated DB/registry; no household disclosures in clips |
+| T04 | `remember_person`: adult/minor/unknown/ambiguous fixtures | A+S; confirmed adult writes approved namespace; other cases enter review; truthful acknowledgement; pending fact cannot be recalled | Age takes precedence over relation; classifier/network failure must not authorize release; do not auto-approve real records |
+| T05 | `think_hard`: explicit self-contained reasoning problem | A+D; actual tool call to configured larger model; correct final answer; tool result/error not hidden by a plausible unrelated reply | Default source model `qwen3.6:27b-think`; bounded slow/failure fallback; next ordinary turn healthy |
+| T06 | `take_photo`: ask what is visible with fresh then stale cache | A+D+V; reads latest description at most 30 seconds old, capped at 300 characters; stale/empty result admitted honestly | Does not trigger fresh photo; route currently picks freshest device globally, so verify single-device prerequisite |
+| T07 | `play_song`: exact catalogue name, partial match, missing name | A+D+V; actual selected asset and playback result; recognizable music reaches microphone; unknown name does not claim playback | Source cache TTL and matching code apply; no automatic music-rights clearance; safe test volume; explicit stop/recovery |
+
+Tool fixtures establish error paths locally; an acoustic tool case still requires
+its own real invocation evidence. Existing voice phrase routing may handle a song
+or state before the LLM, so do not count that interaction as a pi-tool pass.
+
+## Fifteen standard firmware MCP capabilities
+
+Expected source set: five common tools plus ten robot tools below. Save the live
+`tools/list` response and compare names and input schemas. Hardware-conditioned
+screen/camera tools can differ by build. Upstream user-only maintenance tools
+(reboot, upgrade, image upload, asset download) are not part of this ordinary
+15-tool suite and must not be invoked merely to increase coverage.
+
+| ID | MCP tool | Evidence / required assertions | Restoration and edge case |
+|---|---|---|---|
+| M01 | `self.get_device_status` | D; structured speaker/screen/network/battery fields agree with known device | Read-only; unavailable fields remain unavailable |
+| M02 | `self.audio_speaker.set_volume` | D+A; read current value first, apply modest bounded adjustment, observe status and audible result | Restore exact robot volume; never confuse with workstation volume |
+| M03 | `self.screen.set_brightness` | D+V; modest change reflected visibly and in status where available | Restore baseline; avoid extinguishing evidence screen |
+| M04 | `self.screen.set_theme` | D+V; supported light/dark theme produces intended display; invalid theme returns failure | Restore baseline; record if avatar does not visually use theme |
+| M05 | `self.camera.take_photo` | D+V; real fresh camera capture/vision response, matching device and timestamp | Distinct from pi cached tool; honour configured camera/kid/privacy policy and existing provider route |
+| M06 | `self.robot.get_head_angles` | D+V; plausible yaw/pitch agree with observed pose | Read-only; motion can make readings transient |
+| M07 | `self.robot.set_head_angles` | D+V; bounded movement reaches requested pose without jerks or competing writes | Stay within gentle bench envelope, return to baseline; test one-axis omission separately |
+| M08 | `self.robot.set_led_color` | D+V; only left six pixels affected; right ownership retained | StateManager reasserts at 5 Hz; do not demand persistent override of state arc |
+| M09 | `self.robot.set_led_multi` | D+V+S; selected left pixel changes; indices 6–11 rejected; right status remains correct | Invalid/boundary checks in fixtures first; restore state repaint |
+| M10 | `self.robot.set_state` | D+V; legal states reflected in firmware event and physical behaviour; same-state call resyncs without rerunning entry | Unknown string returns false; restore baseline through confirmed exit |
+| M11 | `self.robot.set_toggle` | D+V; kid/smart pips change independently of state; bad names rejected | Firmware setter alone does not prove persistent guardian policy; use dashboard path for end-to-end toggle test |
+| M12 | `self.robot.set_face_identified` | D+P+V; applied/rejected event agrees with real face or recent loss; green expires after about 4 seconds without refresh | Approximately 1.5-second flicker grace; synthetic server face event cannot create firmware detector state |
+| M13 | `self.robot.create_reminder` | D+A+V; returned ID, future entry, due notification tone and readable message | 1–86400 seconds, repeat defaults false; use unique session text and initially nonrepeating reminder |
+| M14 | `self.robot.get_reminders` | D; returned list reflects only expected creates/stops/fires; message JSON remains parseable | Fixture-test quotes/backslashes: current string formatting merits scrutiny; do not mutate household reminders |
+| M15 | `self.robot.stop_reminder` | D+A+V; remove exact created ID before due time and confirm no later notification | Repeat test requires reliable cleanup/dismissal; stop does not prove removal of an already shown popup |
+
+Reminder implementation is in-memory software timing, not demonstrated reboot
+persistence. The expiry callback adds `ReminderView` and plays
+`OGG_NEW_NOTIFICATION`; it does **not** synthesize the message despite the MCP
+description's “what to say” wording. The popup has an on-screen OK button. Perform
+an expiring-reminder test while a human can dismiss it, or prove an existing
+remote dismissal path first. Avoid a sticky popup covering later webcam evidence.
+
+Voice reminder creation is a separate availability test: the seven pi tools do
+not include reminder tools. A polite promise to remind is a failure if no actual
+MCP invocation and scheduled ID exist. Record missing voice exposure as a gap;
+do not add a new tool overnight to fill it.
+
+## States, toggles, expression and motion
+
+| ID | Feature | Stimulus and assertions | Important boundary |
+|---|---|---|---|
+| S01 | `idle` ↔ `talk` | A+D+P+V; cold voice/real face enters talk; appropriate standby/loss exits; left arc off/green; no state conflicts | A continuously open listening session has a different resting expectation |
+| S02 | `story_time` | A+D+V; entry phrases and dashboard seed start a story and show warm arc; supported exit works | Existing state/seeded chat is testable; dedicated interactive-story backing and silence-exit claims require code evidence |
+| S03 | `security` | A+D+V; entry phrase/admin sets state, angry face, deliberate pan and white 1 Hz flashing; exit cancels pan/consumer timer | Real camera and configured security loop may run; audio leg currently missing relay; report each leg separately |
+| S04 | Privacy `sleep` | A+D+V; enter once, home pose/Zzz/dim blue arc/listening off, no continued voice response or face-wake; no autonomous sensing | Negative wake test is success when silent; never repeatedly increase volume to wake sleeping Dotty |
+| S05 | Wake from sleep | P+D+V then A; head touch or dashboard idle restores torque/sensing, wake tilt, then normal cold voice response | Touch path blocked without human; retain a verified dashboard escape before unattended sleep test |
+| S06 | `dance` | A+D+V; named choreography/asset, rainbow left arc, exclusive motion ownership, synchronized ending and healthy next turn | Abort/replacement dance/new sticky state must not be overwritten by stale cleanup |
+| S07 | Kid mode | D+A+V+S; guardian endpoint persists policy and pink pip; voice request cannot toggle it; existing content/camera/person-memory restrictions hold | Do not weaken or rewrite protections to pass tests; restore initial approved setting |
+| S08 | Smart mode | D+V; guardian toggle persists and orange pip follows, with correct configured behaviour gate | No backing-model swap currently promised; voice untoggleable; restore initial setting |
+| S09 | LED ownership | V+D+P; left state arc, right face6/kid8/smart9/listening11, reserved7/10 dark; updates and timeouts agree with events | Need unobstructed/framed rings; distinguish actual flashed layout from old submodule privacy layout |
+| S10 | Face expressions | A+V; smile/laugh/sad/surprise/thinking/angry/neutral/love/sleepy responses display corresponding supported expression | Generated emoji or text is not visual proof; unrecognized emoji and missing prefix are separate regressions |
+
+## Ambient consumers and context
+
+Defaults below come from `dotty-behaviour/config.py` and construction in
+`main.py`; save sanitized deployed values and task health before scheduling.
+An enabled flag with a crashed consumer is a failure, not running coverage.
+
+| ID | Consumer / source defaults | Evidence and expected assertions | Unattended limitation |
+|---|---|---|---|
+| B01 | FaceGreeter: bare 06:00–21:00, 30s cooldown; named 30s cooldown/10s chat quiet | P+A+V+S; bare greet suppressed outside hours or with appearance roster; named identity speaks once and requests face pip; dance gate holds | At night suppression is expected; synthetic tests only prove consumer; avoid private names in clips |
+| B02 | ProactiveGreeter: separate runtime enable/gates | P+A+S; recognized fixture identity yields permitted context-aware greeting, cooldown/persistence suppress duplicates | Inspect deployed `GREETER_ENABLED` and household/calendar gates; do not invent people or events |
+| B03 | SoundTurner: 3s cooldown, ±45° yaw, speed250, 30s post-chat quiet | P+V+S; correct direction when eligible; no self-speech or mid-chat head turn; suppression during protected states | Single fixed speaker cannot verify spatial localization; recorded actual motion still needed |
+| B04 | WakeWordTurner: enabled, ±45° yaw, speed200 | P+A+V+S; wake-direction event yields one intentional turn within motion gates | Distinguish source direction measurement from relay dispatch |
+| B05 | FaceLostAborter: 12s greeting window, 4s loss grace | P+A+S; recent greeting aborts after sustained absence; brief flicker/old greet does not abort unrelated speech | Real audience departure needs human; synthetic events must be labelled |
+| B06 | FaceIdentifiedRefresher: 30s identity TTL, 3s refresh, 2s loss quiet | P+D+V+S; fresh recognized presence refreshes actual green pip; absence/stale identity stops refresh | Firmware applies only with live/recently lost face; API success alone insufficient |
+| B07 | PurrPlayer: 5s cooldown, assumed 2s asset | P+A+V+S; head_pet_started plays purr once; retrigger suppressed; sound-turner quiet during purr | Needs actual head touch and installed asset; synthetic event verifies downstream only |
+| B08 | IdlePhotographer: enabled, random 180–300s, result wait20s, Jaccard0.7 | D+V; only idle/no face/not listening; fresh capture fills cache; notable descriptions logged; repetitive scene suppressed | Reserve true quiet/idle time; an open listening conversation legitimately prevents captures |
+| B09 | SceneSynthesis: enabled, interval300s, minimum gap120s; visionTTL60/audioTTL120 | D+S; fresh cache inputs produce dated text/cache/event; stale-only inputs produce nothing; bursts deduplicate | No LLM call required; cache staleness must remain visible |
+| B10 | SleepDreamer: enabled, 8h window, 3 dreams at 2/4/6h | D+S; scheduled narrative record has device/id/seed/text; leaving sleep cancels outstanding jobs; one failure does not kill schedule | Full timing conflicts with awake ten-minute soak; accelerated isolated test plus partial live observation is not full-duration proof |
+| B11 | DanceReflector: enabled | A+D+S; dance_ended produces one bounded narrative record; no overlap with robot speech or duplicate cleanup | Verify actual source event and persisted timestamp, not old NDJSON |
+| B12 | SecurityCycle: enabled, 20s interval, 5s requested audio, 20s VLM wait, ring60 | D+V+S; security entry starts one timer; fresh photo description each successful cycle; missing audio marked; exit cancels; bounded history | Current missing capture-audio relay means audio leg remains unavailable; preserve configured external vision route |
+| B13 | Vision/audio explain and caches | D+S; device attribution/freshness, failure handling, metadata/photo separation and known fixture content | Workstation recordings/transcripts stay local; do not upload them as test fixtures |
+| B14 | Calendar/weather | D+S; empty calendar IDs is quiet no-op; configured data timestamps/household scoping correct, stale/error visible | Calendar defaults disabled; no event creation; public clip must omit household schedule |
+
+Perception plumbing requires its own assertion: an actual idle-origin firmware
+event lazy-opens WebSocket, relay delivers once to the intended device, bus/SSE
+state agrees, and consumer health survives malformed/duplicate fixture events.
+Synthetic POST success alone cannot demonstrate firmware idle event delivery.
+
+## Dashboard, durability and clip coverage
+
+| ID | Surface | Required assertions and evidence |
+|---|---|---|
+| D01 | `/ui`, status strip, device status, version chip, host cards | D; load/poll without errors, correct versions and connected/disconnected states, stale/unknown health presented honestly |
+| D02 | State, kid/smart controls; LED mirror | D+V; intended action reaches robot, persistence agrees with policy, mirror reflects actual state; invalid requests have no side effects |
+| D03 | Mood, dance, song catalogue/play, say, start-story | D+A+V; validation/filtering, correct target, actual resulting speech/action; no duplicate post action; intended exit/recovery |
+| D04 | Perception, photo/large image, scene/audio, security history and SSE | D+V; current device/time and empty/stale states correct; reconnection updates; proxy failures visible; no stale photo represented as fresh |
+| D05 | Tool inventory, safety history, alerts, memory review | D+S; live capability names match; counters/details agree; approve/redact only isolated test fixtures; protected pending facts not revealed through other views |
+| D06 | Admin devices/songs/say/inject-text/abort/head/state/toggle/photo/asset | D+A+V as applicable; accepted dispatch is followed by correct observable result; unknown/disconnected target handled |
+| R01 | Controlled server restart after baseline | D+A; one approved restart, reconnect and toggle/state resync, new cold/warm turn; no leaked old RPC/answer or lost unrelated data |
+| R02 | Repeated use and ten-minute randomized soak | A+V+D; no overlap, correct response/ending/next turn, latency and resource trends per deployed version; fixed sentinel each sixth slot; missed slots recorded |
+| R03 | Runner/evidence durability | S; process exclusivity, capture continuity, cancellation/deadline, crash checkpoints, midnight timestamps, disk guards and exact artifact provenance |
+| R04 | Repair acceptance | Existing automated tests plus original A/V failure and affected sentinel suite; one variable/commit, deployment ledger, verified rollback; failed experiment retained as evidence |
+| K01 | Social clip export | V+A; complete honest exchange, legible robot/LEDs, continuous sound, accurate captions, source timestamps/version/verdict, portrait output with meaningful framing |
+
+Keep clips under `clips/ready-for-review`, `clips/needs-review` and
+`clips/failures`; all retain the original recording. Music, private names/facts,
+uncertain captions and humorous failures are explicit review flags. No automatic
+publication. Clip count does not substitute for feature coverage.
+
+Known coverage gaps to carry into the morning report: physical touch/face/spatial
+stimuli without an operator; full-duration dreaming while running awake soak;
+missing firmware or voice exposure for a listed capability; unimplemented
+dedicated story backing; absent security audio relay; policy-gated camera paths;
+independent acoustic or visual verification failures; reminder popup dismissal;
+and any dashboard card that lacks current source data. Disabled-by-configuration,
+unsupported, blocked, inconclusive and failed are distinct outcomes. None count
+as a physical pass.
diff --git a/docs/dotty-overnight.md b/docs/dotty-overnight.md
new file mode 100644
index 00000000..eb4dbeec
--- /dev/null
+++ b/docs/dotty-overnight.md
@@ -0,0 +1,70 @@
+# Overnight Dotty verification
+
+AI-assisted: OpenAI Codex (GPT-6), from Brett's approved September 12 session plan.
+
+The coordinator (`scripts/dotty_overnight.py`) runs bounded physical cases,
+collects four-service logs, records continuous C920 video/audio, and transcribes
+prompt/response windows locally. It never deploys fixes: the supervising agent
+owns scoped experiments, committed checkpoints, backups and verified rollback.
+
+## Session commands
+
+Use one session directory under ignored `uat-sessions/`. `init` requires a
+working local evaluator Python environment and model paths as described by its
+generated config. The September 12 session uses `overnight-2200` beneath that
+day's folder; `config.json` records the resolved sink, device and deadline.
+
+```bash
+python scripts/dotty_overnight.py init --session SESSION --host '<XIAOZHI_USER>@<XIAOZHI_HOST>'
+python scripts/dotty_overnight.py preflight --session SESSION
+python scripts/dotty_overnight.py run --session SESSION --cases V01-identity --once
+python scripts/dotty_overnight.py status --session SESSION
+python scripts/dotty_overnight.py stop --session SESSION
+python scripts/dotty_overnight.py resume --session SESSION
+python scripts/dotty_overnight.py report --session SESSION
+```
+
+Initialization requires an explicit SSH destination (`--host` or
+`DOTTY_TEST_HOST`); existing sessions use their recorded configuration.
+
+Device/audio/SSH access must run in the host environment, not a sandbox that
+hides `/dev` or PipeWire. Do not modify a running shell script: finish/cancel
+the case before installing the next harness revision.
+
+`STOP` cancels owned processes; three consecutive failures pause prompting.
+Interrupted cases are quarantined and require explicit review before retry.
+Only cases explicitly marked `soak_safe` may be chosen for ten-minute repeats.
+Each ordinary case needs three consecutive acoustic passes before coverage is
+considered provisionally demonstrated. Missing visual evidence is inconclusive.
+
+## Capture correction established on this bench
+
+Direct FFmpeg ALSA input reported a 36-second AAC duration but decoded only
+2.142 seconds of actual samples. Increasing input queues did not repair it.
+Microphone-only `arecord` worked. Capturing the same C920 via its PipeWire/Pulse
+source produced 35.98 seconds of PCM in a 36-second recording. The harness now
+defaults to this route; `DOTTY_AV_AUDIO_BACKEND=alsa` remains an explicit fallback.
+
+Verification asserts decoded sample coverage and maximum timestamp gaps, not
+just container duration. ALSA xruns must not be dismissed on duration alone.
+The volume in this particular calibrated session is 100% software with Brett's
+previously confirmed physical knob position; it is not a recommendation for
+another bench. Never raise volume automatically when a wake phrase fails.
+
+## Evidence and claims
+
+The microphone must hear the prompt; server ASR must understand its semantics;
+response-window microphone transcription must match the requested answer;
+service TTS must complete; physical state must meet the case's contract.
+Generated TTS text is supporting evidence, not proof of audible speech.
+
+Live configuration keeps auto-listening open (`close_connection_no_voice_time`
+is one day); follow-up readiness can therefore be `talk` with listening true,
+after TTS LAST. This is distinct from an explicit idle transition. Privacy
+sleep disables acoustic wake in the active firmware; use its supported
+dashboard/touch exit and never weaken that policy to satisfy an outdated test.
+
+Camera framing and LED/expression review remain separate gates. Check
+`coverage.json` for pending, blocked and implemented-but-untested features.
+See `dotty-overnight-clips.md` for local portrait review exports. No upload or
+unattended merge is part of this workflow.
diff --git a/docs/dotty-voice-camera-policy.md b/docs/dotty-voice-camera-policy.md
new file mode 100644
index 00000000..569c76d0
--- /dev/null
+++ b/docs/dotty-voice-camera-policy.md
@@ -0,0 +1,58 @@
+# Voice-camera Kid Mode policy — review candidate
+
+TL;DR: this local repair guards **voice-requested** physical capture and cached
+camera descriptions separately. It is **pending human safety/red-team review**;
+software tests do not establish live deployment or a global camera-off guarantee.
+
+## Enforcement boundaries
+
+| Boundary | Adult mode | Kid Mode or unreadable policy |
+| --- | --- | --- |
+| Spoken vision shortcut in `receiveAudioHandle.py` | Existing camera MCP and image-result path | Denied before capture; no successful-photo context is constructed |
+| Behaviour `/api/voice/take_photo` | Existing fresh <=30-second cached description, capped at 300 characters | Fixed structured denial before inspecting the cache |
+
+Both read the bridge-owned `DOTTY_KID_MODE_STATE` file for every access. Only an
+explicit `false`, `0`, or `no` enables adult camera access. Missing, unreadable,
+invalid UTF-8 or malformed state fails closed, even if a startup environment
+flag says adult mode. This is intentionally stricter than the legacy toggle
+reader; ordinary content-filter and LED toggle behavior is unchanged.
+
+The behaviour Compose candidate adds a read-only directory mount of the existing
+bridge state at `/var/lib/dotty-bridge/state`. Mounting the directory follows file
+replacement; it does not create a second toggle store. Deployments must map this
+to the same guardian-controlled state directory used by bridge and xiaozhi.
+Do not use behaviour's startup-only `app.state.kid_mode` flag as the authority.
+
+The registered `take_photo` tool is a **cached-description read**, not a new
+photo. The spoken vision shortcut can physically capture before Pi is called,
+so guarding only the Pi tool does not protect that route.
+
+## Deliberate scope and review requirements
+
+This does not disable ambient face detection, security/idle capture, guardian
+dashboard/admin capture, or an external webcam. It does not claim those paths
+share this voice-access policy. Existing safety/content filters remain intact.
+
+Before deployment, a human must review the child-policy change and the shared
+read-only mount. Follow CONTRIBUTING's safety-change discussion and red-team
+documentation requirements; obtain separate deployment approval. Do not deploy
+only the physical shortcut guard while leaving cached voice access unguarded.
+
+Required review checks:
+
+- A fresh synthetic cache is denied in Kid Mode; a stale cache alone cannot
+  establish denial. Verify no camera MCP or cached content exposure.
+- Toggle adult -> kid -> adult without restarting either service and verify
+  allow -> deny -> allow at both boundaries.
+- Missing, unreadable and malformed shared state must deny camera access.
+- Valid adult policy preserves physical capture and cached freshness behavior.
+- Spoken denial must not be turned into “the photo shows ...” or a claim that a
+  photo was taken. Confirm the microphone reply and execution evidence separately.
+- Re-run existing content-filter, emoji and per-person-memory review tests.
+  No household memory write is required for these checks.
+
+Regression tests use synthetic state and mocked dispatch; no private camera data
+or live services are required. New tests first failed against the unguarded code.
+
+AI-assisted implementation/documentation: OpenAI Codex (GPT-6). Human review and
+accountability are required. Last reviewed by agent: 2026-09-12; not deployed.
diff --git a/docs/hardware.md b/docs/hardware.md
index 54af87ec..e7bf1736 100644
--- a/docs/hardware.md
+++ b/docs/hardware.md
@@ -10,7 +10,7 @@ description: M5Stack StackChan hardware specs, CoreS3 ESP32-S3 SoC, and servo ch
 - The robot body is the **M5Stack StackChan** kit: an M5Stack **CoreS3** (ESP32-S3) head on a 2-servo chassis.
 - The CoreS3 supplies the SoC, display, camera, mic array, speaker, IMU, proximity, microSD — all integrated. NFC and the IR tx/rx pair physically live on the kit body, not the CoreS3 (see the kit table below).
 - The *StackChan kit* adds the head-yaw servo, head-pitch servo, 12 RGB LEDs, 3-zone touch panel, 550 mAh supplementary battery, USB-C, NFC, an IR tx/rx pair, an IO expander, a dedicated battery monitor, and the 3D-printed body. A separate handheld ESP-NOW remote controller ships in the same box (M5Stack's product page describes it as an ESP-NOW wireless remote).
-- Firmware on the device is built from [`m5stack/StackChan`](https://github.com/m5stack/StackChan) — an Arduino C++ codebase that bundles the **XiaoZhi AI agent** client. It is **not** the same codebase as `meganetaaan/stack-chan` (the original Moddable/JS project) or `78/xiaozhi-esp32` (generic voice-assistant firmware).
+- Firmware on the device is built from the pinned [`BrettKinny/StackChan@dotty`](https://github.com/BrettKinny/StackChan/tree/dotty) fork of [`m5stack/StackChan`](https://github.com/m5stack/StackChan). It bundles the **XiaoZhi AI agent** client plus Dotty's state, motion, LED, privacy, and perception changes. It is **not** the same codebase as `meganetaaan/stack-chan` (the original Moddable/JS project) or a direct build of `78/xiaozhi-esp32` (generic voice-assistant firmware).
 - The device advertises itself over the Xiaozhi WebSocket protocol and exposes **on-device tools via MCP** (see [protocols.md](./protocols.md)).
 - Canonical hardware reference: [`docs.m5stack.com/en/StackChan`](https://docs.m5stack.com/en/StackChan) (kit-level) and [`docs.m5stack.com/en/core/CoreS3`](https://docs.m5stack.com/en/core/CoreS3) (head unit). See [references.md](./references.md#hardware).
 
@@ -80,10 +80,11 @@ Three related codebases — do not confuse them:
 | Repo | Language | Purpose | Runs on StackChan? |
 |---|---|---|---|
 | [`meganetaaan/stack-chan`](https://github.com/meganetaaan/stack-chan) | TypeScript / JavaScript on Moddable SDK | Original open-source Stack-chan (Shinya Ishikawa) | Yes (but not what we run) |
-| [`m5stack/StackChan`](https://github.com/m5stack/StackChan) | Arduino C++ | M5Stack's official firmware — bundles XiaoZhi AI agent, targets CoreS3 | **Yes — this is what we flash** |
+| [`BrettKinny/StackChan@dotty`](https://github.com/BrettKinny/StackChan/tree/dotty) | ESP-IDF / C++ | Dotty's pinned fork of M5Stack's firmware — bundles XiaoZhi and the Dotty-specific firmware contract | **Yes — build the pinned submodule** |
+| [`m5stack/StackChan`](https://github.com/m5stack/StackChan) | ESP-IDF / C++ | Official upstream firmware | Upstream only; do not flash directly for Dotty |
 | [`78/xiaozhi-esp32`](https://github.com/78/xiaozhi-esp32) | Arduino C++ | Generic multi-board voice assistant firmware (70+ target boards) | Runs on the same ESP32-S3 but is a different application — you pick one, not both |
 
-Our pipeline uses `m5stack/StackChan` because it comes with the robot-body integration (servos, avatar rendering, LED patterns, MCP tools mapped to peripherals) already done. `78/xiaozhi-esp32` is the upstream *protocol* reference — the voice channel speaks the same WebSocket protocol regardless.
+Our fork inherits M5Stack's robot-body integration (servos, avatar rendering, LED patterns, MCP tools mapped to peripherals) and adds Dotty's firmware behaviour. `78/xiaozhi-esp32` is the upstream *protocol* reference — the voice channel speaks the same WebSocket protocol regardless.
 
 ## On-device MCP tools
 
@@ -91,7 +92,7 @@ The device acts as an **MCP server** — after the WS `hello` handshake, it adve
 
 Tool names follow the dotted-namespace convention from the `78/xiaozhi-esp32` MCP protocol doc (e.g. `self.audio_speaker.set_volume`, `self.get_device_status`). The **registration sites** in the firmware use `McpServer::AddTool` for public tools and `McpServer::AddUserOnlyTool` for privileged/hidden ones.
 
-Per internal deployment observation, the live firmware advertises **11 tools**. The mapping below is from that observation plus the `m5stack/StackChan` README's feature list — **verify against the handshake logs** (`docker logs xiaozhi-esp32-server | grep tools/list`) before relying on exact tool names:
+The live Dotty firmware advertises the upstream hardware tools plus Dotty's state/toggle additions. The mapping below is from deployment observation and the pinned fork — **verify against the handshake logs** (`docker logs xiaozhi-esp32-server | grep tools/list`) before relying on exact tool names:
 
 | # | Tool (functional) | Hardware touched |
 |---|---|---|
diff --git a/docs/interaction-map.md b/docs/interaction-map.md
index 492bb29d..835aabe9 100644
--- a/docs/interaction-map.md
+++ b/docs/interaction-map.md
@@ -9,7 +9,7 @@ One-page reference for every cross-layer signal in the Dotty stack.
 
 **Layers:**
 
-1. **StackChan firmware** -- ESP32-S3 (m5stack/StackChan). The physical robot.
+1. **StackChan firmware** -- ESP32-S3 (`BrettKinny/StackChan@dotty`, forked from `m5stack/StackChan`). The physical robot.
 2. **xiaozhi-esp32-server** -- Docker on a Linux host. Voice I/O pipeline (ASR, TTS, VAD, emotion parsing).
 3. **dotty-pi** -- the pi coding agent (Docker container on the same host). The LLM brain; reached by xiaozhi-server's `PiVoiceLLM` provider via `docker exec` pi RPC. (Ambient perception runs in a sibling `dotty-behaviour` container — see [architecture.md](./architecture.md).)
 
diff --git a/docs/latent-capabilities.md b/docs/latent-capabilities.md
index d8942e70..6b2c4b8e 100644
--- a/docs/latent-capabilities.md
+++ b/docs/latent-capabilities.md
@@ -63,7 +63,7 @@ Features xiaozhi-esp32-server supports upstream that aren't turned on or surface
 | **Streaming first-token to TTS** | First-token TTS instead of waiting for the full response (perceived-latency win) | **High** | `ROADMAP.md` → "Reduce first-audio latency" |
 | **Long-lived pi agent sessions** | Carry context across turns within a conversation without re-loading the persona each time | Medium | `ROADMAP.md` → "Reduce first-audio latency" |
 | **Tool pre-approval gate** | Bridge confirms tool calls before they execute — useful for child-safety. | Medium | `ROADMAP.md` → "Lock down for child-safe operation" |
-| ~~**Tool-use**~~ | **Wired up.** The `dotty-pi-ext` extension exposes 5 voice tools (`memory_lookup`, `remember`, `think_hard`, `take_photo`, `play_song`). | Done | — |
+| ~~**Tool-use**~~ | **Wired up.** The `dotty-pi-ext` extension exposes 7 voice tools (`memory_lookup`, `remember`, `recall_person`, `remember_person`, `think_hard`, `take_photo`, `play_song`). | Done | — |
 | **pi agent MCP-server mode** | Expose the agent's tools/memory to other MCP clients | Low | **New-task candidate** |
 | **Qwen3 `role: "system"` injection** | Move the English+emoji constraints into a proper system message instead of a prompt prefix/suffix; better MoE adherence | Medium | Rework of persona prompt structure |
 | **Qwen3 extended context (96K native)** | Keep long conversation history / memory verbatim instead of summarising | Low | Costs more tokens per turn — probably not worth it yet |
diff --git a/docs/modes.md b/docs/modes.md
index 4358dff6..49bca515 100644
--- a/docs/modes.md
+++ b/docs/modes.md
@@ -12,7 +12,7 @@ This document is the source of truth for Dotty's high-level modes. The model has
 
 The firmware **StateManager** modifier (`firmware/main/stackchan/modes/state_manager.{h,cpp}`) owns both axes. It paints the state arc (left ring 0-5) + toggle pips at 5 Hz, drives the idle-motion profile, and emits `state_changed` perception events on every transition. The **dotty-behaviour** perception bus (`dotty-behaviour/perception/state.py`) consumes those events and runs 11 consumer classes (the running set is config-gated) against them (`FaceGreeter`, `SoundTurner`, `FaceLostAborter`, `WakeWordTurner`, `FaceIdentifiedRefresher`, `PurrPlayer`, `SceneSynthesis`, `IdlePhotographer`, `SleepDreamer`, `DanceReflector`, `SecurityCycle`) — see [architecture.md](./architecture.md#perception-event-bus).
 
-> **Submodule pin caveat.** Phase 4 shipped to the active firmware fork (`BrettKinny/StackChan @ dotty`, commit `d78118b`) on **2026-04-27**. The `firmware/firmware/` submodule pin in this repo deliberately lags upstream — it's a release pointer, not the active development tree. A user who flashes from the submodule will get a pre-Phase-4 firmware. Bump the submodule (or build from the active fork) to get the StateManager. Visual / interactive bench checks tracked in [issue #38](https://github.com/BrettKinny/dotty-stackchan/issues/38).
+> **Submodule pin caveat.** Phase 4 shipped to the active firmware fork (`BrettKinny/StackChan @ dotty`, commit `d78118b`) on **2026-04-27**. The historical pin `35f701a` predates StateManager; the pin checked on **2026-09-12**, `969c2b2`, includes StateManager and privacy sleep. The `firmware/` submodule remains a release pointer, not the active development tree: do not assume it contains every subsequent fix. The sleep contract below was checked against active-fork `3140f03`; compare your build before using it as an acceptance baseline. Visual / interactive bench checks are tracked in [issue #38](https://github.com/BrettKinny/dotty-stackchan/issues/38).
 
 Pair this with [hardware.md](./hardware.md) (the physical LED ring + servos) and [interaction-map.md](./interaction-map.md) (the underlying signals).
 
@@ -26,7 +26,7 @@ Pair this with [hardware.md](./hardware.md) (the physical LED ring + servos) and
 | Toggle | compose freely | `kid_mode`, `smart_mode` | firmware StateManager + bridge state files |
 | Chat sub-state | nested under `talk` / `story_time` | listening (LED) / thinking + speaking (face only) | xiaozhi-server |
 
-The firmware boots into `idle` with both toggles **off**. The bridge resyncs toggles from disk on the first turn after each reconnect. State transitions land via voice phrases, camera edges (`face_detected` → `talk`), head-pet hold (sleep → idle), or `/xiaozhi/admin/set-state` from the dashboard.
+The firmware boots into `idle` with both toggles **off**. The bridge resyncs toggles from disk on the first turn after each reconnect. State transitions land via voice phrases, camera edges (`face_detected` → `talk` while awake), head touch (sleep → idle), or `/xiaozhi/admin/set-state` from the dashboard.
 
 **Speech sub-states** are conveyed by face animations (eye gestures, talking mouth) and the dedicated **listening pixel** at right-ring index 11. `thinking` and `speaking` have no LED — they live on the face. `listening` lights pixel 11 red so the user knows when their voice is being captured as a turn.
 
@@ -42,24 +42,29 @@ The firmware boots into `idle` with both toggles **off**. The bridge resyncs tog
 | `talk` | dim green `(0,60,0)` | NORMAL (face_tracking overlay active) | Conversation engaged. Listening pixel (right 11) lights red while the user has the turn; `thinking` and `speaking` are face-animation only. | xiaozhi → PiVoiceLLM → dotty-pi |
 | `story_time` | warm `(100,40,0)` | NORMAL | Long-running interactive story. | Phase 7 PENDING — backing path unimplemented |
 | `security` | white `(80,80,80)` **flashing 1 Hz** across all 6 left pixels (`kSecurityFlashHalfMs = 500`) | SURVEILLANCE | Wide deliberate scan, serious face, periodic photo + audio capture. No proactive greet. | Phase 8 PENDING — `SecurityCycle` consumer is scaffolding, not a live path |
-| `sleep` | very dim blue `(0,0,16)` | SLEEPY | Head face-down + centred, servo torque off (with `kSleepTorqueReleaseTimeoutMs = 3000` fallback), sleeping emoji on screen, ambient awareness paused. Wakes on face / voice / head-pet. | firmware-only quiescence (Phase 5) |
+| `sleep` | very dim blue `(0,0,16)` | SLEEPY | Neutral home pose, then servo torque off after settling (with `kSleepTorqueReleaseTimeoutMs = 3000` fallback); sleepy emoji + `Zzz…`. Face detection, voice processing, and wake-word detection disabled. Exit by head touch or explicit dashboard/admin state change, not face or voice. | firmware privacy sleep (Phase 5) |
 | `dance` | rainbow sweep (left ring) | NORMAL | Transient performance — server-owned named choreography + audio. Firmware holds the cooperative motion lock so face tracking and idle motion cannot overwrite MCP keyframes. | `receiveAudioHandle.py::_handle_dance` |
 
 The `idle → talk` trigger is the firmware `face_detected` event (any face, family or stranger) **or** `onVoiceListening` (the WS opens for a wake-word / inject-text / head-pet hold). dotty-behaviour runs VLM recognition in parallel and feeds the resulting identity into the speaker resolver / persona — recognition does **not** gate the state transition.
 
 ### Mutex rules
 
-1. Exactly **one** state is current. `setState(S)` to the same state is a no-op.
+1. Exactly **one** state is current. `setState(S)` to the same state skips entry/exit effects but still emits `state_changed` to resync observers.
 2. State transitions are explicit — no implicit "fallback" to idle from other states; each non-idle state has its own exit triggers.
 3. Camera edges only auto-transition between `idle` ↔ `talk`. Sticky states (`story_time`, `security`, `sleep`, `dance`) ignore `face_detected` / `face_lost`.
 
 ### Wake-from-sleep edges
 
-`StateManager` accepts three sleep-exit triggers:
+Privacy sleep has two supported exit paths:
 
-- **Face detected** (`onFaceDetected`) — wakes if `_state == State::Sleep`.
-- **Voice listening** (`onVoiceListening`) — wakes on wake-word, inject-text, or any other path that opens the WS.
-- **Head pet** (`onHeadPet`) — the dark-room friendly path; capacitive head touch wakes without line of sight or speech. See [voice-mode-entry.md](./voice-mode-entry.md).
+- **Head touch** (`onHeadPet`) — capacitive touch immediately changes `sleep` → `idle`, without line of sight or speech. Continuing to hold for ≥2 seconds separately invokes the hold-to-listen path. See [voice-mode-entry.md](./voice-mode-entry.md).
+- **Explicit state change** — the dashboard or `/xiaozhi/admin/set-state` with `state: "idle"` exits sleep through `StateManager::setState`.
+
+On entry, `onEnterSleep` parks at neutral home (firmware coordinates yaw 0, pitch 0), takes the motion lock, disables the face detector, clears the listening flag, and engages `Application::SetPrivacyGate(true)`. That gate disables voice processing and wake-word detection and prevents state changes from re-arming them during sleep. The face detector releases its camera-stream guard on its next tick; the stream stops when no other camera consumer holds it. This describes the normal perception/voice producers, not a hardware power-disconnect guarantee or an audit of every independent camera API.
+
+The `onFaceDetected` and `onVoiceListening` hooks still exist, but in the checked active firmware they transition **only from `idle`**, never from `sleep`. Their presence is not evidence of physical sleep-wake capability: those producers are disabled in privacy sleep, and stale callbacks cannot exit it. Neither saying the wake word nor walking into camera view should wake Dotty. Injected text also bypasses acoustic input and is not an acoustic wake test.
+
+On exit, firmware restores torque **before** issuing the wake tilt (yaw 0, pitch 70 in firmware coordinates), releases the motion lock, clears `Zzz…`, restores a neutral face, enables face detection, and lifts the privacy gate. Normal face/listening transitions may then take `idle` to `talk`.
 
 ---
 
@@ -78,10 +83,10 @@ The two toggles are orthogonal — they compose freely. `kid_mode = on` AND `sma
 
 ## LED contract (12-pixel ring)
 
-!!! warning "Two firmwares, two right-ring layouts"
+!!! warning "Historical firmware has a different right-ring layout"
     The contract below describes the **active-fork Phase 4 StateManager**
-    (`BrettKinny/StackChan @ dotty`). The firmware **submodule pinned in this
-    repo** (`35f701a`) does **not** include StateManager — it ships the
+    (`BrettKinny/StackChan @ dotty`). The **historical** submodule pin
+    `35f701a` predates StateManager — it ships the
     **privacy-LED** layout instead, which claims two of the same right-ring
     pixels for a different purpose:
 
@@ -90,10 +95,11 @@ The two toggles are orthogonal — they compose freely. `kid_mode = on` AND `sma
     - **pixel 11** = camera indicator (red when the camera is capturing)
 
     These are bound to the codec/camera hardware via RAII guards (see the
-    firmware's `main/stackchan/privacy/PRIVACY_LEDS.md`). So if you flash from
-    the submodule, **pixels 6 and 11 mean mic/camera — not face-state and
-    listening.** The face-state pip, toggle pips, and listening pip described
-    below arrive once StateManager lands in the submodule pin.
+    firmware's `main/stackchan/privacy/PRIVACY_LEDS.md`). On that historical
+    build, **pixels 6 and 11 mean mic/camera — not face-state and listening.**
+    The pin checked on 2026-09-12 (`969c2b2`) already includes StateManager;
+    do not apply the old layout merely because a build uses the submodule.
+    Check the actual firmware revision when interpreting the LEDs.
 
 ```
 LEFT RING (global 0–5)              RIGHT RING (global 6–11)
@@ -137,7 +143,7 @@ stateDiagram-v2
     talk --> idle: face_lost grace expired (firmware) / onVoiceStandby
 
     idle --> sleep: voice "go to sleep" / "goodnight Dotty"
-    sleep --> idle: face_detected / voice / head_pet
+    sleep --> idle: head_pet / admin set-state idle
 
     idle --> security: voice "keep watch" / "security mode"
     security --> idle: voice "wake up" / face_detected (Phase 6)
@@ -162,6 +168,8 @@ stateDiagram-v2
 | `tell me a story` / `story time` | `story_time` |
 | `wake up` / `come back` / `are you there` (only when state ∈ `{sleep, security, story_time}`) | `idle` |
 
+This table describes server-side phrase parsing after text arrives. Its `sleep` condition does **not** make speech an available sleep-exit path: privacy sleep disables the physical voice/wake-word producers. Use head touch or the explicit state endpoint to wake the device before an acoustic conversation test.
+
 Both `kid_mode` and `smart_mode` are voice-untoggleable — they are guardian-controlled axes driven from the bridge's `/admin/kid-mode` and `/admin/smart-mode` endpoints (or the dashboard cards that wrap them).
 
 ### Admin endpoints
@@ -189,10 +197,10 @@ Both `kid_mode` and `smart_mode` are voice-untoggleable — they are guardian-co
 | State | Voice path | Memory? | Tools? |
 |---|---|---|---|
 | `idle` | n/a | n/a | n/a |
-| `talk` | xiaozhi → PiVoiceLLM → dotty-pi | yes (FTS via `memory_lookup` / `remember` tools in dotty-pi-ext) | yes (5-tool dotty-pi-ext catalogue) |
+| `talk` | xiaozhi → PiVoiceLLM → dotty-pi | yes (FTS via `memory_lookup` / `remember` tools in dotty-pi-ext) | yes (7-tool dotty-pi-ext catalogue; see [brain.md](./brain.md)) |
 | `story_time` | Phase 7 PENDING — backing path unimplemented | n/a (pending) | n/a (pending) |
 | `security` | Phase 8 PENDING — `SecurityCycle` consumer is scaffolding, no live path | n/a (pending) | n/a (pending) |
-| `sleep` | mic stays on for "wake up"; no LLM round-trip | n/a | n/a |
+| `sleep` | voice processing and wake-word detection off; no acoustic wake or LLM turn | n/a | n/a |
 | `dance` | xiaozhi handler dispatches choreography + audio file; firmware state supplies exclusive motion ownership, not a second choreography | n/a | head/LED MCP |
 
 `smart_mode` is a toggle only and sticky across turns; the backing model-swap it was designed to drive is v2 scope and not wired on the `PiVoiceLLM` path. `story_time` (when implemented) would be the only voice path with its own session memory (Phase 7 pending).
@@ -215,10 +223,12 @@ Phase 4 established the *rails* — pip, transition events, dispatch helpers, vo
 
 ## Sources of truth
 
-- **Firmware (active fork `BrettKinny/StackChan @ dotty`):** `firmware/main/stackchan/modes/state_manager.{h,cpp}`, `firmware/main/stackchan/modifiers/face_tracking.cpp` (camera-edge hooks), `firmware/main/hal/hal_mcp.cpp` (set_state / set_toggle MCP). **This repo's submodule pin lags** — bump it (or maintain a parallel checkout per the [`firmware/`](../firmware) README) to flash a build that includes Phase 4+.
+- **Firmware (active fork `BrettKinny/StackChan @ dotty`):** `firmware/main/stackchan/modes/state_manager.{h,cpp}`, `firmware/main/stackchan/modifiers/face_tracking.cpp` (camera-edge hooks), `firmware/main/stackchan/modifiers/head_pet.cpp` (touch/hold distinction), `firmware/xiaozhi-esp32/main/application.cc` (`SetPrivacyGate`, represented in the fork's upstream patch), and `firmware/main/hal/hal_mcp.cpp` (set_state / set_toggle MCP). This repo's release pin includes Phase 4+, but can lag later hardening; compare it with the active checkout before flashing. See the [`firmware/`](../firmware) README.
 - **Perception + ambient behaviour:** `dotty-behaviour/perception/state.py` (the perception event bus + per-device `current_state` from `state_changed`) and `dotty-behaviour/consumers/` (the 11 consumer classes — the running set is config-gated: `FaceGreeter`, `SoundTurner`, `FaceLostAborter`, `WakeWordTurner`, `FaceIdentifiedRefresher`, `PurrPlayer`, `SceneSynthesis`, `IdlePhotographer`, `SleepDreamer`, `DanceReflector`, `SecurityCycle`). The old `bridge.py` `_perception_*` / `_update_perception_state` / `_capture_room_view` methods are retired.
 - **Bridge:** `bridge.py` (admin dashboard + the `/admin/kid-mode` and `/admin/smart-mode` toggle relays), `receiveAudioHandle.py` (voice state phrases + per-conn toggle sync). The voice-path model-swap helpers (`_apply_model_swap`, `_apply_tier1slim_runtime`) are retired along with the Tier1Slim provider; smart-mode model-swap is v2 scope.
 - **xiaozhi-server patches:** `custom-providers/xiaozhi-patches/http_server.py` (`/xiaozhi/admin/set-state`, `/xiaozhi/admin/set-toggle`, `/xiaozhi/admin/set-face-identified`, `/xiaozhi/admin/inject-text`, `/xiaozhi/admin/abort`, `/xiaozhi/admin/set-head-angles`), `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py` (`state_changed` → `conn.current_state`, perception relay to dotty-behaviour)
 - **Dashboard:** `bridge/dashboard.py` + `bridge/templates/state_card.html` + `bridge/templates/smart_mode.html` + `bridge/templates/led_ring_mirror.html`
 
 Last verified: 2026-05-17.
+
+Sleep/privacy, release-pin caveats, and seven-tool count source-audited 2026-09-12 against active firmware `3140f03` and release pin `969c2b2`. This targeted documentation correction was AI-assisted (OpenAI Codex, GPT-6); it does not claim a fresh physical verification of every mode.
diff --git a/docs/quickstart.md b/docs/quickstart.md
index f2b1895d..00976e0a 100644
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -51,6 +51,18 @@ Download the latest release from
 `bootloader.bin`, `partition-table.bin`, `ota_data_initial.bin`,
 `stack-chan.bin`, `generated_assets.bin`, and `human_face_detect.espdl`.
 
+> **Self-hosting note:** the current `fw-v1.3.3` prebuilt was compiled for
+> the maintainer's LAN (`CONFIG_OTA_URL` points at that deployment). It is a
+> reproducible release artifact, but it is not a portable binary for another
+> self-hosted server. There is no OTA/server editor in the StackChan's
+> on-device Settings app. For your own server, build from source with
+> `CONFIG_OTA_URL="http://<XIAOZHI_HOST>:8003/xiaozhi/ota/"` before flashing;
+> [SETUP.md](../SETUP.md#2-build-and-flash-open-firmware) has the reliable
+> procedure using this repo's pinned `BrettKinny/StackChan@dotty` submodule.
+> Do not build the official `m5stack/StackChan` upstream directly: it does not
+> include Dotty's firmware changes. A browser tab named **Advanced** exists
+> only in the Xiaozhi hotspot portal.
+
 Install esptool and flash over USB-C:
 
 ```bash
@@ -141,10 +153,24 @@ No separate host, no systemd bridge unit, no SSH to a second machine.
 
 ## 6. Connect the robot
 
-1. Power on the robot (USB-C or battery).
-2. On the device screen, navigate to **Settings > Advanced Options**.
-3. Enter the OTA URL: `http://<XIAOZHI_HOST>:8003/xiaozhi/ota/`
-4. The robot connects via WebSocket and shows a face.
+1. Confirm the firmware was built with
+   `CONFIG_OTA_URL="http://<XIAOZHI_HOST>:8003/xiaozhi/ota/"` as described in
+   [SETUP.md](../SETUP.md#2-build-and-flash-open-firmware).
+2. Power on the robot (USB-C or battery).
+3. On a fresh flash, **“Welcome! Let's get started.” is expected**. Tap
+   **Skip** to bypass the M5Stack account wizard. If the launcher remains,
+   open **SETUP** and use its home control to exit into Xiaozhi.
+4. Join the temporary `Xiaozhi-*` hotspot, open the browser URL shown on the
+   robot (normally `http://192.168.4.1`), and select your 2.4 GHz Wi-Fi.
+   The portal's **Advanced** tab can confirm or override `ota_url`.
+5. Watch `docker logs -f xiaozhi-esp32-server`. The robot should POST to the
+   configured OTA URL, receive the WebSocket endpoint, connect, and show a
+   face.
+
+The StackChan's on-device Settings app does **not** contain an Advanced
+Options or OTA URL field. Wi-Fi credentials are provisioned into NVS through
+the browser hotspot portal; `CONFIG_WIFI_SSID` and `CONFIG_WIFI_PASSWORD` are
+not firmware options in the pinned source.
 
 ## 7. First voice turn
 
@@ -228,7 +254,7 @@ The full file inventory lives in [architecture.md](./architecture.md#deployment-
 
 | What | URL | Who calls it |
 |---|---|---|
-| OTA (enter into StackChan settings) | `http://<XIAOZHI_HOST>:8003/xiaozhi/ota/` | The robot on boot |
+| OTA (compile into firmware or set in the hotspot portal) | `http://<XIAOZHI_HOST>:8003/xiaozhi/ota/` | The robot on boot |
 | WebSocket | `ws://<XIAOZHI_HOST>:8000/xiaozhi/v1/` | The robot after OTA handshake |
 | Perception / ambient events | `http://<XIAOZHI_HOST>:8090` | xiaozhi-server → dotty-behaviour |
 | Admin dashboard | `http://<XIAOZHI_HOST>:8081/ui` | Humans (LAN-only HTMX UI) |
diff --git a/docs/references.md b/docs/references.md
index 261d0355..9ace8e21 100644
--- a/docs/references.md
+++ b/docs/references.md
@@ -15,7 +15,8 @@ source-of-truth for re-verification.
 | Resource | URL | What's there |
 |---|---|---|
 | M5Stack StackChan product page | https://docs.m5stack.com/en/StackChan | Canonical kit-level reference. Part numbers, I2C addresses, pin map, servo angle limits, battery (550 mAh), assembled dims, in-box remote. |
-| M5Stack StackChan README | https://github.com/m5stack/StackChan | Our firmware codebase. Body spec (servos, LEDs, NFC, IR, touch, battery). |
+| Dotty StackChan firmware fork | https://github.com/BrettKinny/StackChan/tree/dotty | Pinned firmware source used by this repo. |
+| M5Stack StackChan README | https://github.com/m5stack/StackChan | Upstream firmware and body spec (servos, LEDs, NFC, IR, touch, battery). |
 | M5Stack CoreS3 datasheet | https://docs.m5stack.com/en/core/CoreS3 | SoC, memory, display, camera, IMU, PMU, audio codec part numbers. |
 | meganetaaan/stack-chan (original) | https://github.com/meganetaaan/stack-chan | TypeScript/Moddable JS origin project — **we don't run this**, but it's the lineage. |
 | 78/xiaozhi-esp32 firmware (generic) | https://github.com/78/xiaozhi-esp32 | Multi-board voice-assistant firmware. Authority for the WS + MCP protocols below. |
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index e87850f8..bae14532 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -67,7 +67,7 @@ Symptom-first lookup table covering common and obscure failure modes. Pair with
 **Fix:**
 1. Check the bridge health endpoint: `curl http://<XIAOZHI_HOST>:8081/health`. If the bridge is down, restart it.
 2. Check xiaozhi-server logs: `docker logs -f xiaozhi-esp32-server` on the server. Look for connection attempts from the robot.
-3. Verify the robot's OTA URL hasn't changed. After a firmware update, re-enter the OTA URL (`http://<XIAOZHI_HOST>:8003/xiaozhi/ota/`) in the robot's Advanced Options if needed.
+3. Verify which OTA URL the firmware was built with. The StackChan's on-device Settings app has no OTA URL field. For another self-hosted server, rebuild with `CONFIG_OTA_URL="http://<XIAOZHI_HOST>:8003/xiaozhi/ota/"` and re-flash using [SETUP.md](../SETUP.md#2-build-and-flash-open-firmware). If the device is currently exposing the optional Xiaozhi SoftAP captive portal, its browser-based **Advanced** tab can persist an `ota_url` override instead.
 4. Open the browser test page (`repo/main/xiaozhi-server/test/test_page.html`) and point it at `ws://<XIAOZHI_HOST>:8000/xiaozhi/v1/`. If the browser page works but the robot doesn't, it's a robot-side configuration issue.
 
 ---
diff --git a/docs/uat-runbook.md b/docs/uat-runbook.md
index e97e17a7..bcc42870 100644
--- a/docs/uat-runbook.md
+++ b/docs/uat-runbook.md
@@ -140,15 +140,18 @@ face events and survive chat-turn ends; `wake up` / `come back` /
 | US5 | Voice: *"keep watch"* **⚠ pending** | Within ~3 s: yaw sweep −500→+500→0, angry face latched, pixel 0 flashing white 1 Hz | `state_changed` → `security`; `security capture loop started … interval=20s` | "Dotty guards the house" — the sweep is very filmable |
 | US6 | Stay in security ≥40 s | Sweep continues | security NDJSON gains records with `photo_desc` (+20 s cadence); `audio_capture_pending` errors expected (#31) | QA-only; feeds UD10 |
 | US7 | Voice: *"wake up"* (exit security) | Pan stops ≤4 s, head home, neutral face | `security capture loop cancelled`; NDJSON stops | tail of the US5 clip |
-| US8 | Voice: *"goodnight Dotty"* | Smooth face-down travel (~3–4 s), pixel 0 very dim blue, 😴 + `Zzz…`, torque-release click ~1 s after settle | `state_changed` → `sleep` | "Putting my robot to bed" — reliably charming |
-| US9 | While asleep: idle ~30 s, lights on | Gentle droop, **no** idle motion | no idle-motion servo commands | part of US8 clip |
-| US10 | Wake path 1 — voice: *"wake up"* | Torque re-engages **first** (audible), wake-tilt to ~70 pitch, neutral face, idle | `state_changed` → `idle` | "Three ways to wake a robot" 1/3 |
-| US11 | Sleep again; wake path 2 — **pet her head** | Same wake sequence, lands in **idle** (not talk) | `head_pet_started` | 2/3 |
-| US12 | Sleep again; wake path 3 — **walk into camera view** | Wakes straight to **talk** (pixel 0 cyan), looks up then at you | `face_detected` → talk | 3/3 — the best one |
+| US8 | Voice: *"goodnight Dotty"* | Neutral home pose, left arc very dim blue, 😴 + `Zzz…`; torque releases after settling or the 3 s fallback | `state_changed` → `sleep`; privacy gate engaged, face detector and voice/wake-word processing disabled | "Putting my robot to bed" |
+| US9 | While asleep: idle ~30 s, lights on | Quiet, **no** idle motion, listening indicator off | no idle-motion commands or new face/listening producer activity after sleep settles | part of US8 clip |
+| US10 | Privacy check — say the configured wake word and *"wake up"* | Remains asleep; no listening or wake tilt | no wake detection or sleep-exit transition attributable to speech | Show the actual privacy behavior; do not claim voice wake |
+| US11 | While asleep, briefly **touch the head** | Torque re-engages before wake tilt, neutral face; initial transition to **idle**. Continued ≥2 s hold separately requests listening | `head_pet_started` then `state_changed` → `idle`; later face/listening transitions are separate | "A gentle touch wakes Dotty" |
+| US12 | Sleep again; **walk into camera view** | Remains asleep; no face-driven wake | no new face-driven sleep-exit transition | Privacy check, not a face-wake demonstration |
+| US12a | While asleep, explicitly select **idle** in the dashboard | Wake tilt, `Zzz…` clears; normal perception resumes | admin acknowledgement plus `state_changed` → `idle` | Label as dashboard wake, not acoustic verification |
 | US13 | Awake: provoke a sleepy reply (ask her if she's tired → 😴) | Legacy hard-sleep path still works | 😴 emotion frame | QA-only |
 | US14 | Voice/dashboard: trigger **dance** | Left ring rainbow sweep, choreography + song | `state_changed` → `dance`; `_handle_dance` | The flagship Short. Film generously |
 | US15 | From dashboard, click the **current** state's button | `state_changed` still fires (idempotent re-set), dashboard cache refreshes | `state_changed` on idempotent set | QA-only |
 
+Sleep rows US8–US12a follow active firmware `3140f03` (source audit 2026-09-12); they are acceptance instructions, not recorded passes. See [modes.md](./modes.md#wake-from-sleep-edges) for the privacy contract and release-pin caveat. This targeted correction is AI-assisted (OpenAI Codex, GPT-6).
+
 ## Phase UL — toggles & the LED contract
 
 | ID | Brett does (on camera) | Expected — eyes/video | Expected — logs (Claude) | Shorts framing |
@@ -175,7 +178,7 @@ Live checks first, then the timer/env-gated consumers verified by **evidence**
 | UP1 | From idle, walk into view, face 30–60 cm, well lit | Pixel 6 yellow ≤1 s; possible "Hi!" greeting (hour-gated) | `phase0 det>0`; `face_detected`; FaceGreeter | "She notices when I walk in" |
 | UP2 | Stay in frame for VLM identify | Pixel 6 → **green**; named greeting if roster-matched | FaceIdentifiedRefresher keeps it green past the 4 s firmware timeout; `set-face-identified` hits | "My robot knows my face" |
 | UP3 | Start her talking, then walk out of frame mid-reply | TTS aborts after the grace window (audience gone) | `face_lost` → FaceLostAborter | "She stops talking when you leave. Rude? Efficient?" |
-| UP4 | From idle, off-camera-side: snap fingers / clap left, then right | Head turns toward each sound | `sound_event` (direction/balance) → SoundTurner | "Sneaking up on my robot (impossible)" |
+| UP4 | From idle, off-camera-side: snap fingers / clap left, then right | Head turns toward each sound | `sound_event` (direction/balance) → SoundTurner (needs `SOUND_TURN_ENABLED=1`; off by default until the stuck-left localizer in #27 is calibrated) | "Sneaking up on my robot (impossible)" |
 | UP5 | From across the room, say the wake word | Fast head-turn to the speaker | `wake_word_detected` → WakeWordTurner (if `WAKE_TURN_ENABLED`) | pairs with UP4 |
 | UP6 | Pet her head while awake | Hearts + happy face + **purr** sound; no state change | `head_pet_started` → PurrPlayer | "Yes, the robot purrs." Instant clip |
 | UP7 | Return to idle, leave the room 2+ min (camera keeps rolling) | Idle-motion cadence drops 4–8 s → 15–30 s; walk back in → cadence recovers in seconds | idle-motion timing in serial | Time-lapse: "robot gets bored" |
@@ -204,7 +207,7 @@ dashboard works well for Shorts).
 | UD5 | Memory card: find UT4's pending kid fact → **approve** it; **redact** another | Pending → approved queue move; redacted fact gone; `recall_person` now sees the approved one | `/ui/actions/memory/{approve,redact}` | QA-critical (human-review loop); clip optional |
 | UD6 | Tools-inventory card | If it lists 5 legacy entries, record presentation FAIL; separately verify Pi registers all 7 voice tools | Pi RPC/tool-startup evidence is authoritative | QA-only |
 | UD7 | Safety card after UL2 | The kid-mode filter hit from UL2 listed (last 20) | `/ui/safety/recent` | QA-only |
-| UD8 | Activity feed: cycle All / Turns / Events / Errors chips; open the errors modal | Live SSE turns + perception events streaming; errors modal renders | `/ui/events` SSE + `/api/perception/feed`; `/ui/alerts/detail` | B-roll: the feed scrolling during a chat |
+| UD8 | Activity feed: cycle All / Turns / Events / Errors chips; open the errors modal | Live SSE turns + perception events streaming; errors modal renders | `/ui/events` SSE + `/ui/perception/feed` (bridge relay of dotty-behaviour `/api/perception/feed`); `/ui/alerts/detail` | B-roll: the feed scrolling during a chat |
 | UD9 | Perception card + vision modal: open latest photo large, download | Latest VLM photo + description, audio caption, last voice line, scene sentence | `/ui/vision/large`, `/ui/vision/photo?download=1` | "What my robot sees" |
 | UD10 | Security panel (after US5–US7): open security scene history | Capture records from the US6 window render | `/ui/security/recent/{device_id}` | pairs with the US5 clip |
 | UD11 | LED-ring mirror page while toggling kid_mode on the robot | Mirror tracks the physical ring ≤2 s (HTMX poll) | `/ui/led-ring-mirror` | split-screen: physical ring vs mirror |
diff --git a/docs/voice-mode-entry.md b/docs/voice-mode-entry.md
index ff700ce1..0795a3c2 100644
--- a/docs/voice-mode-entry.md
+++ b/docs/voice-mode-entry.md
@@ -7,6 +7,8 @@ description: Every way to invite Dotty into a voice turn — wake word, face det
 
 A "voice turn" is the moment Dotty switches from passive idle to actively listening: the wake-word path opens, the mic opens, ASR captures speech, the LLM responds, and TTS plays. There are four distinct ways to enter that state today. This page collects them in one place, with a comparison table at the end so you can pick the right one for the room you're in.
 
+**Idle is not sleep.** In [privacy sleep](./modes.md#wake-from-sleep-edges), face detection, voice processing, and wake-word detection are disabled. Head touch or an explicit dashboard/admin state change must exit sleep first. The entry paths below describe an awake device; injected text is not evidence of acoustic wake.
+
 The default phrase is **"Hi, ESP"** (firmware shipped this as the default in a recent change). See [wake-word.md](./wake-word.md) for how to change it.
 
 ## Entry paths
@@ -15,7 +17,7 @@ The default phrase is **"Hi, ESP"** (firmware shipped this as the default in a r
 
 > **"Hi, ESP" (default), "Hi, Stack Chan", "Computer", or any of the prebuilt WakeNet9 phrases.**
 
-The classic path. The mic is always sampling at low cost (AFE + WakeNet9 INT8 on the ESP32-S3). When the wake-net spots the phrase, `Application::HandleWakeWordDetectedEvent` opens the WebSocket and the robot transitions to listening. Works with no line of sight, no touch, no LAN. **Requires the user to speak.**
+The classic path. While awake with wake-word detection armed, the mic samples at low cost (AFE + WakeNet9 INT8 on the ESP32-S3). When the wake-net spots the phrase, `Application::HandleWakeWordDetectedEvent` opens the WebSocket and the robot transitions to listening. Detection is local and needs no line of sight or touch; opening the server conversation still needs connectivity. **Requires the user to speak. Disabled during privacy sleep.**
 
 Cross-link: [wake-word.md](./wake-word.md) covers the whole stack — current model, the five-minute switch to a different prebuilt, and the long-term branded "Hey Dotty" microWakeWord roadmap.
 
@@ -25,7 +27,7 @@ The on-device face tracker (PSRAM-mounted ESP-WHO model in `firmware/firmware/ma
 
 A per-device minimum interval (`FACE_GREET_MIN_INTERVAL_SEC`, default 30 s) stops a stationary user from re-triggering on every blink of the tracker. Set `FACE_GREET_TEXT=""` to suppress the verbal greeting and just open the mic silently — these knobs live in `dotty-behaviour/config.py`.
 
-**Requires line of sight.** Useless in the dark or when the camera is occluded.
+**Requires line of sight and an enabled face detector.** Unavailable in privacy sleep, in the dark, or when the camera is occluded. The StateManager face hook only enters `talk` from `idle`; it does not wake `sleep`.
 
 ### 3. Head-pet hold — firmware
 
@@ -33,6 +35,8 @@ A per-device minimum interval (`FACE_GREET_MIN_INTERVAL_SEC`, default 30 s) stop
 
 Shipped in firmware commit `e8370d2`. The head-pet handler distinguishes a quick swipe (visual purr feedback only — see Path B in `head_pet.h`) from a sustained hold; on hold-detected the firmware fires `Application::WakeWordInvoke("head_pet_hold")` directly, which is exactly what the wake-net would do for a real wake-word hit. The mic opens, no audible cue.
 
+When asleep, the initial capacitive **press** first invokes `onHeadPet`, changing `sleep` to `idle` and lifting the privacy gate. A continued ≥2-second hold separately requests listening. A brief touch wakes without itself requesting a voice turn; normal face detection may engage `talk` after wake.
+
 This is the **dark-room friendly** entry point: works with no light, no line of sight, no spoken phrase. Brett's primary use case is morning interactions before the lights are up.
 
 ### 4. `/xiaozhi/admin/inject-text` — server-side LAN admin
@@ -41,17 +45,21 @@ This is the **dark-room friendly** entry point: works with no light, no line of
 
 This is the path the portal "Greet" button and `dotty-behaviour` consumers (e.g. `face_greeter`) use. Strictly speaking it doesn't enter voice mode — it bypasses the listen pipeline entirely and inserts text directly into the LLM turn, skipping wake-word + ASR. Useful when you want Dotty to say something **without anyone needing to be physically present**: scheduled greetings, DM-style admin messages, automation hooks. Not exposed to the public internet.
 
+For a sleeping device, use the explicit `/xiaozhi/admin/set-state` endpoint with `state: "idle"` before testing a conversation. An injected prompt is an administrative test, not a physical sleep-wake or ASR test.
+
 ## Comparison
 
 | Entry path | Works in dark | Line of sight | Spoken utterance | Touch | LAN admin | Cooldown |
 |---|---|---|---|---|---|---|
-| Wake word ("Hi, ESP") | yes | no | yes | no | no | none (always armed) |
+| Wake word ("Hi, ESP") | yes | no | yes | no | no | none while armed; disabled in privacy sleep |
 | Face detected | no | yes | no | no | no | per-device, `FACE_GREET_MIN_INTERVAL_SEC` |
 | Head-pet hold (≥2 s) | yes | no | no | yes | no | none (immediate WakeWordInvoke) |
 | `/admin/inject-text` | yes | no | no | no | yes | none |
 
 ## Choosing for your room
 
+These choices assume Dotty is awake. In privacy sleep, touch the head or explicitly select `idle` in the dashboard first.
+
 - **Lights on, you're across the room**: wake word.
 - **Lights on, you're right in front of Dotty**: face detection beats waiting for the wake-net every time.
 - **Lights off, hands free**: wake word still works.
@@ -65,3 +73,5 @@ This is the path the portal "Greet" button and `dotty-behaviour` consumers (e.g.
 - [voice-pipeline.md](./voice-pipeline.md) — what happens *after* the listen window opens (VAD → ASR → LLM → TTS).
 - [modes.md](./modes.md) — the broader mode taxonomy and LED contract.
 - [interaction-map.md](./interaction-map.md) — every Dotty-side input/output, including the non-voice ones.
+
+Sleep-entry distinctions source-audited against active firmware `3140f03` on 2026-09-12. Documentation correction AI-assisted by OpenAI Codex (GPT-6).
diff --git a/docs/voice-pipeline.md b/docs/voice-pipeline.md
index 79e023e9..30d1cb18 100644
--- a/docs/voice-pipeline.md
+++ b/docs/voice-pipeline.md
@@ -81,7 +81,7 @@ Pick one via `selected_module.LLM` in `.config.yaml`. The default is `PiVoiceLLM
 
 #### `PiVoiceLLM` (default)
 
-Custom provider at `custom-providers/pi_voice/` (mounted into `/opt/xiaozhi-esp32-server/core/providers/llm/pi_voice/`). It doesn't run a model itself — it hands each voice turn to the **`dotty-pi` container** by running `docker exec -i dotty-pi pi --mode rpc` and exchanging JSONL messages over stdio. The pi agent owns the conversation loop (`qwen3.5:4b` on local llama-swap) and the five `dotty-pi-ext` voice tools (`memory_lookup`, `remember`, `think_hard`, `take_photo`, `play_song`); only TTS-bound text streams back. See [brain.md](./brain.md).
+Custom provider at `custom-providers/pi_voice/` (mounted into `/opt/xiaozhi-esp32-server/core/providers/llm/pi_voice/`). It doesn't run a model itself — it hands each voice turn to the **`dotty-pi` container** by running `docker exec -i dotty-pi pi --mode rpc` and exchanging JSONL messages over stdio. The pi agent owns the conversation loop (`qwen3.5:4b` on local llama-swap) and the seven `dotty-pi-ext` voice tools (`memory_lookup`, `remember`, `recall_person`, `remember_person`, `think_hard`, `take_photo`, `play_song`); only TTS-bound text streams back. See [brain.md](./brain.md).
 
 #### `OpenAICompat` (alternate)
 
diff --git a/dotty-behaviour/config.py b/dotty-behaviour/config.py
index c66aeec0..c0b0e378 100644
--- a/dotty-behaviour/config.py
+++ b/dotty-behaviour/config.py
@@ -67,6 +67,11 @@ def _env_float(name: str, default: float) -> float:
 STATE_DIR: Path = Path(
     os.environ.get("DOTTY_STATE_DIR", "/var/lib/dotty-behaviour/state")
 )
+# Camera voice access uses the canonical bridge-owned policy file, not this
+# daemon's independent state directory or startup-only app.state.kid_mode.
+KID_MODE_STATE_FILE: Path = Path(os.environ.get(
+    "DOTTY_KID_MODE_STATE", "/var/lib/dotty-bridge/state/kid-mode"
+))
 LOG_DIR: Path = Path(
     os.environ.get("CONVO_LOG_DIR", "/var/lib/dotty-behaviour/logs")
 )
@@ -101,6 +106,14 @@ def _env_float(name: str, default: float) -> float:
 FACE_LOST_ABORT_GRACE_SEC: float = _env_float("FACE_LOST_ABORT_GRACE_SEC", 4.0)
 
 # sound_turner — gentler "curious about an ambient noise" head turn.
+# Disabled by default (2026-10-05): the firmware SoundLocalizer is still
+# stuck-left (#27, closed not-planned pending a calibration bench session)
+# — every sound_event reports balance >= 0.996 / direction "left", so the
+# turner snaps the head left on any noise. Set SOUND_TURN_ENABLED=1 only
+# after deliberate left/right claps classify correctly.
+SOUND_TURN_ENABLED: bool = (
+    os.environ.get("SOUND_TURN_ENABLED", "0") in ("1", "true", "True")
+)
 SOUND_TURN_COOLDOWN_SEC: float = _env_float("SOUND_TURN_COOLDOWN_SEC", 3.0)
 SOUND_TURN_YAW_DEG: int = _env_int("SOUND_TURN_YAW_DEG", 45)
 SOUND_TURN_SPEED: int = _env_int("SOUND_TURN_SPEED", 250)
diff --git a/dotty-behaviour/consumers/sound_turner.py b/dotty-behaviour/consumers/sound_turner.py
index a0286831..fed9f8c7 100644
--- a/dotty-behaviour/consumers/sound_turner.py
+++ b/dotty-behaviour/consumers/sound_turner.py
@@ -7,6 +7,7 @@
 Mirrors bridge.py's `_perception_sound_turner` including:
 
   * skip if face_present (face tracker owns gaze)
+  * skip outside idle or while listening/dancing (those paths own motion)
   * skip if a chat happened within QUIET_AFTER_CHAT_SEC
     (the user's own continuing speech shouldn't yank Dotty around)
   * per-device cooldown
@@ -72,6 +73,10 @@ async def run(self) -> None:
 
                 now = event.ts
                 dev_state = self._state.state.setdefault(device_id, {})
+                if (self._state.current_device_state(device_id) != "idle"
+                        or dev_state.get("listening")
+                        or self._state.is_dance_active(device_id)):
+                    continue
                 if dev_state.get("face_present"):
                     continue
                 last_chat = dev_state.get("last_chat_t", 0.0)
diff --git a/dotty-behaviour/docker-compose.yml b/dotty-behaviour/docker-compose.yml
index e306138f..eca9922f 100644
--- a/dotty-behaviour/docker-compose.yml
+++ b/dotty-behaviour/docker-compose.yml
@@ -47,9 +47,13 @@ services:
       # Daemon state (kid-mode/smart-mode toggle files, greeter state,
       # household.yaml)
       - DOTTY_STATE_DIR=/var/lib/dotty-behaviour/state
+      # Voice-camera policy must follow the guardian's live shared toggle.
+      - DOTTY_KID_MODE_STATE=/var/lib/dotty-bridge/state/kid-mode
       - HOUSEHOLD_YAML_PATH=/var/lib/dotty-behaviour/state/household.yaml
       - GREETER_STATE_PATH=/var/lib/dotty-behaviour/state/greeter_state.json
     volumes:
+      # Read-only directory mount follows atomic replacement of the state file.
+      - /mnt/user/appdata/dotty-bridge/state:/var/lib/dotty-bridge/state:ro
       - /mnt/user/appdata/dotty-behaviour/state:/var/lib/dotty-behaviour/state
       - /mnt/user/appdata/dotty-behaviour/logs:/var/lib/dotty-behaviour/logs
       - /mnt/user/appdata/dotty-behaviour/secrets:/var/lib/dotty-behaviour/secrets:ro
diff --git a/dotty-behaviour/main.py b/dotty-behaviour/main.py
index 0b5938de..efa40ab3 100644
--- a/dotty-behaviour/main.py
+++ b/dotty-behaviour/main.py
@@ -74,7 +74,13 @@ async def lifespan(app: FastAPI):
     # Singleton perception state — bus + caches + per-device dicts.
     # Stored on app.state so routes/consumers can retrieve it via
     # FastAPI's Request.app.state.
-    state = PerceptionState()
+    # Persist only the last state_changed mutex per device. This survives a
+    # daemon/container restart through the existing mounted STATE_DIR, but is
+    # not an authoritative sync for firmware changes made while this service
+    # was offline; the next relayed state_changed event remains authoritative.
+    state = PerceptionState(
+        state_path=config.STATE_DIR / "perception-state.json"
+    )
     app.state.perception = state
 
     # Singleton dispatch clients — outbound HTTP to xiaozhi-server's
@@ -146,14 +152,6 @@ async def lifespan(app: FastAPI):
             window_sec=config.FACE_LOST_ABORT_WINDOW_SEC,
             grace_sec=config.FACE_LOST_ABORT_GRACE_SEC,
         ),
-        SoundTurner(
-            state,
-            xiaozhi,
-            cooldown_sec=config.SOUND_TURN_COOLDOWN_SEC,
-            yaw_deg=config.SOUND_TURN_YAW_DEG,
-            speed=config.SOUND_TURN_SPEED,
-            quiet_after_chat_sec=config.SOUND_TURN_QUIET_AFTER_CHAT_SEC,
-        ),
         FaceIdentifiedRefresher(
             state,
             xiaozhi,
@@ -169,6 +167,20 @@ async def lifespan(app: FastAPI):
             duration_sec=config.PURR_DURATION_SEC,
         ),
     ]
+    if config.SOUND_TURN_ENABLED:
+        consumers.append(
+            SoundTurner(
+                state,
+                xiaozhi,
+                cooldown_sec=config.SOUND_TURN_COOLDOWN_SEC,
+                yaw_deg=config.SOUND_TURN_YAW_DEG,
+                speed=config.SOUND_TURN_SPEED,
+                quiet_after_chat_sec=config.SOUND_TURN_QUIET_AFTER_CHAT_SEC,
+            )
+        )
+    else:
+        log.info("sound turner disabled by SOUND_TURN_ENABLED=0 (see #27)")
+
     if config.WAKE_TURN_ENABLED:
         consumers.append(
             WakeWordTurner(
diff --git a/dotty-behaviour/perception/state.py b/dotty-behaviour/perception/state.py
index e5baab77..d0143b6f 100644
--- a/dotty-behaviour/perception/state.py
+++ b/dotty-behaviour/perception/state.py
@@ -14,9 +14,12 @@ class so the daemon can construct an isolated instance per test and
 
 import asyncio
 import collections
+import json
 import logging
+import os
 import time
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Iterable
 
 from config import (
@@ -27,6 +30,10 @@ class so the daemon can construct an isolated instance per test and
 
 log = logging.getLogger("dotty-behaviour.perception")
 
+_DURABLE_DEVICE_STATES = frozenset(
+    {"idle", "talk", "story_time", "security", "sleep", "dance"}
+)
+
 
 @dataclass(frozen=True)
 class PerceptionEvent:
@@ -59,12 +66,13 @@ class PerceptionState:
     construct instances directly.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, *, state_path: str | Path | None = None) -> None:
+        self._state_path = Path(state_path) if state_path is not None else None
         # Event bus
         self._listeners: list[asyncio.Queue[PerceptionEvent]] = []
         # Per-device state (face_present, listening, current_state,
         # last_*_t timestamps, dance_active, etc.)
-        self.state: dict[str, dict[str, Any]] = {}
+        self.state: dict[str, dict[str, Any]] = self._load_state()
         # Bounded per-device ring buffer of recent events (dashboard).
         self._recent: dict[
             str, collections.deque[dict[str, Any]]
@@ -89,6 +97,51 @@ def __init__(self) -> None:
         # the pattern).
         self._audio_waiters: dict[str, list[asyncio.Event]] = {}
 
+    def _load_state(self) -> dict[str, dict[str, Any]]:
+        if self._state_path is None:
+            return {}
+        try:
+            payload = json.loads(self._state_path.read_text(encoding="utf-8"))
+            if isinstance(payload, dict) and all(
+                isinstance(device_id, str)
+                and isinstance(device_state, dict)
+                and device_state.get("current_state") in _DURABLE_DEVICE_STATES
+                and isinstance(
+                    device_state.get("last_state_change_t", 0.0),
+                    (int, float),
+                )
+                for device_id, device_state in payload.items()
+            ):
+                return payload
+        except (OSError, json.JSONDecodeError):
+            pass
+        return {}
+
+    def _persist_state(self) -> None:
+        if self._state_path is None:
+            return
+        try:
+            self._state_path.parent.mkdir(parents=True, exist_ok=True)
+            temporary = self._state_path.with_name(f".{self._state_path.name}.tmp")
+            durable_state = {
+                device_id: {
+                    "current_state": device_state["current_state"],
+                    "last_state_change_t": device_state.get(
+                        "last_state_change_t", 0.0
+                    ),
+                }
+                for device_id, device_state in self.state.items()
+                if isinstance(device_state.get("current_state"), str)
+                and device_state["current_state"]
+            }
+            temporary.write_text(
+                json.dumps(durable_state, separators=(",", ":")),
+                encoding="utf-8",
+            )
+            os.replace(temporary, self._state_path)
+        except OSError as exc:
+            log.warning("failed to persist perception state: %s", exc)
+
     # ------------------------------------------------------------------
     # Bus
     # ------------------------------------------------------------------
@@ -191,6 +244,7 @@ def update_state(
                     state["dance_active"] = True
                 elif state.get("dance_active"):
                     state["dance_active"] = False
+                self._persist_state()
         elif name == "dance_started":
             state["dance_active"] = True
             state["last_dance_started_t"] = ts
@@ -201,6 +255,10 @@ def update_state(
             listening = bool(data.get("listening"))
             state["listening"] = listening
             state["last_chat_status_t"] = ts
+            # Both edges are conversation activity: stop/listening-off often
+            # precedes Dotty's own TTS. Preserve PurrPlayer's future reservation
+            # and never move the quiet-after-chat clock backwards.
+            state["last_chat_t"] = max(ts, state.get("last_chat_t", 0.0))
         elif name == "face_recognized":
             identity = (data.get("identity") or "").strip()
             if identity:
diff --git a/dotty-behaviour/routes/perception.py b/dotty-behaviour/routes/perception.py
index 7ee89973..860a8902 100644
--- a/dotty-behaviour/routes/perception.py
+++ b/dotty-behaviour/routes/perception.py
@@ -15,7 +15,6 @@
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
-from config import PERCEPTION_RECENT_MAX
 from perception import PerceptionEvent, PerceptionState
 
 router = APIRouter(prefix="/api/perception")
@@ -93,37 +92,12 @@ async def perception_recent(
 ) -> list[dict]:
     """Most-recent perception events for a device (newest first).
 
-    Bounded by PERCEPTION_RECENT_MAX. Used by the bridge dashboard
+    Bounded by the PERCEPTION_RECENT_MAX ring size. Used by the bridge dashboard
     perception card.
     """
     return state.get_recent(device_id, limit=limit)
 
 
-@router.get("/sound-balance/{device_id}")
-async def sound_balance_series(
-    device_id: str,
-    limit: int = 30,
-    state: PerceptionState = Depends(get_perception_state),
-) -> list[float]:
-    """Recent sound_event balance values for a device (oldest-first).
-
-    Used by the bridge dashboard state-card sparkline. Returns at most
-    ``limit`` recent values; missing/non-numeric balances are skipped.
-    Iterates the recent-events ring (newest-first) in reverse so the
-    output is oldest-first — matches the sparkline's left-to-right
-    time axis.
-    """
-    recent = state.get_recent(device_id, limit=PERCEPTION_RECENT_MAX)
-    balances: list[float] = []
-    for event in reversed(recent):
-        if event.get("name") != "sound_event":
-            continue
-        balance = event.get("data", {}).get("balance")
-        if isinstance(balance, (int, float)):
-            balances.append(float(balance))
-    return balances[-limit:]
-
-
 @router.get("/feed")
 async def perception_feed(
     request: Request,
diff --git a/dotty-behaviour/routes/voice.py b/dotty-behaviour/routes/voice.py
index 52c6bdca..3abeb18d 100644
--- a/dotty-behaviour/routes/voice.py
+++ b/dotty-behaviour/routes/voice.py
@@ -13,6 +13,7 @@
 
 from fastapi import APIRouter, Depends, Request
 
+import config
 from perception import PerceptionState
 
 log = logging.getLogger("dotty-behaviour.routes.voice")
@@ -28,6 +29,21 @@ def get_perception_state(request: Request) -> PerceptionState:
 TAKE_PHOTO_FRESHNESS_SEC = 30.0
 TAKE_PHOTO_FALLBACK = "(I can't see anything fresh right now)"
 TAKE_PHOTO_MAX_CHARS = 300
+TAKE_PHOTO_DENIED = "(Camera access is disabled in Kid Mode)"
+
+
+def camera_access_denied() -> bool:
+    """Fail closed unless the current shared policy explicitly allows adults.
+
+    Deliberately do not fall back to a startup env flag or the unsynchronized
+    app.state toggle. Read on every request so dashboard changes apply live.
+    Keep this camera-only contract in sync with receiveAudioHandle.py.
+    """
+    try:
+        value = config.KID_MODE_STATE_FILE.read_text(encoding="utf-8").strip().lower()
+    except (OSError, UnicodeError):
+        return True
+    return value not in ("false", "0", "no")
 
 
 router = APIRouter()
@@ -45,6 +61,9 @@ async def voice_take_photo(
     nothing is fresh. Future v2: actively fire take_photo MCP and await
     a new capture.
     """
+    if camera_access_denied():
+        return {"description": TAKE_PHOTO_DENIED, "denied": True,
+                "reason": "kid_mode_camera_denied"}
     best_desc = ""
     best_age = float("inf")
     now = perf_counter()
diff --git a/dotty-behaviour/tests/test_cached_voice_camera_policy.py b/dotty-behaviour/tests/test_cached_voice_camera_policy.py
new file mode 100644
index 00000000..026e7d9a
--- /dev/null
+++ b/dotty-behaviour/tests/test_cached_voice_camera_policy.py
@@ -0,0 +1,69 @@
+"""Cached voice-camera policy boundary; AI-assisted by Codex (GPT-6)."""
+import asyncio
+from time import perf_counter
+from types import SimpleNamespace
+
+from fastapi import FastAPI
+from httpx import AsyncClient, ASGITransport
+import pytest
+
+import config
+from routes.voice import get_perception_state, router
+
+
+def request(state):
+    app = FastAPI()
+    app.include_router(router)
+    # Deliberately stale adult flag: the shared file must win.
+    app.state.kid_mode = False
+    async def fake_state():
+        return state
+    app.dependency_overrides[get_perception_state] = fake_state
+    async def run():
+        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://synthetic") as client:
+            return await client.get("/api/voice/take_photo")
+    return asyncio.run(run())
+
+
+@pytest.fixture
+def policy(tmp_path, monkeypatch):
+    path = tmp_path / "kid-mode"
+    monkeypatch.setattr(config, "KID_MODE_STATE_FILE", path, raising=False)
+    monkeypatch.setenv("DOTTY_KID_MODE", "false")
+    return path
+
+
+class ForbiddenCache:
+    def values(self):
+        raise AssertionError("denied camera policy must not inspect cached descriptions")
+
+
+@pytest.mark.parametrize("value", ["true", "1", "yes", "", "garbage", None])
+def test_denied_or_unknown_policy_never_reads_cache(policy, value):
+    if value is not None:
+        policy.write_text(value)
+    response = request(SimpleNamespace(vision_cache=ForbiddenCache()))
+    assert response.status_code == 200
+    assert response.json()["denied"] is True
+    assert "Kid Mode" in response.json()["description"]
+
+
+def test_unreadable_or_invalid_policy_is_denied(policy):
+    policy.mkdir()
+    assert request(SimpleNamespace(vision_cache=ForbiddenCache())).json()["denied"] is True
+    policy.rmdir()
+    policy.write_bytes(b"\xff")
+    assert request(SimpleNamespace(vision_cache=ForbiddenCache())).json()["denied"] is True
+
+
+def test_toggle_refresh_and_adult_cache_contract(policy):
+    state = SimpleNamespace(vision_cache={"fixture": {
+        "description": "Synthetic cobalt cube.", "timestamp": perf_counter()}})
+    for value, denied in [("false", False), ("true", True), ("0", False), ("yes", True), ("no", False)]:
+        policy.write_text(value)
+        response = request(state).json()
+        if denied:
+            assert response["denied"] is True
+            assert "cobalt" not in response["description"]
+        else:
+            assert response == {"description": "Synthetic cobalt cube."}
diff --git a/dotty-behaviour/tests/test_calendar.py b/dotty-behaviour/tests/test_calendar.py
index 8ba61977..90af109d 100644
--- a/dotty-behaviour/tests/test_calendar.py
+++ b/dotty-behaviour/tests/test_calendar.py
@@ -6,6 +6,7 @@
 
 from fastapi.testclient import TestClient
 
+import config
 from calendar_ import (
     CalendarCache,
     Event,
@@ -143,9 +144,12 @@ def test_cache_set_and_flush() -> None:
     assert c.calendar_date == "2026-05-19"
 
 
-def test_calendar_today_route_returns_shape() -> None:
+def test_calendar_today_route_returns_shape(monkeypatch) -> None:
     """With CALENDAR_IDS unset (test env), the route should respond
     with the empty-cache shape and not blow up trying to fetch."""
+    # Keep this route-shape test hermetic. WEATHER_LOCATION defaults to
+    # Brisbane in production, which would otherwise contact wttr.in.
+    monkeypatch.setattr(config, "WEATHER_LOCATION", "")
     with TestClient(app) as client:
         r = client.get("/api/calendar/today")
         assert r.status_code == 200
diff --git a/dotty-behaviour/tests/test_consumer_sound_turner.py b/dotty-behaviour/tests/test_consumer_sound_turner.py
index dbf37817..e643a80f 100644
--- a/dotty-behaviour/tests/test_consumer_sound_turner.py
+++ b/dotty-behaviour/tests/test_consumer_sound_turner.py
@@ -5,12 +5,96 @@
 import asyncio
 import time
 
+import pytest
+
 from consumers import SoundTurner
 from perception import PerceptionEvent, PerceptionState
 
 from ._fakes import FakeXiaozhi, let_consumer_settle
 
 
+@pytest.mark.parametrize("chat_state,listening", [
+    ("talk", True), ("talk", False), ("idle", True),
+    ("sleep", False), ("dance", False), ("security", False), ("story_time", False),
+])
+def test_real_state_and_chat_events_suppress_sound_turns(chat_state, listening) -> None:
+    """Reproduce physical own-TTS turns through the relay's update+broadcast seam.
+
+    AI-assisted regression: OpenAI Codex (GPT-6).
+    """
+    async def go() -> None:
+        state = PerceptionState()
+        xiaozhi = FakeXiaozhi()
+
+        async def body() -> None:
+            for name, data, ts in (
+                ("state_changed", {"state": chat_state}, 100.0),
+                ("chat_status", {"listening": listening}, 101.0),
+                # Even once quiet-after-chat elapsed, an active chat/state wins.
+                ("sound_event", {"direction": "right"}, 200.0),
+            ):
+                state.update_state("dev-1", name, data, ts)
+                state.broadcast(PerceptionEvent(device_id="dev-1", name=name, data=data, ts=ts))
+                await let_consumer_settle()
+            assert xiaozhi.set_head_angles_calls == []
+            assert not any(e["name"] == "head_turn" for e in state.get_recent("dev-1"))
+
+        await _spin(state, xiaozhi, body)
+
+    asyncio.run(go())
+
+
+def test_real_chat_stop_protects_quiet_interval_then_idle_sound_turns() -> None:
+    async def go() -> None:
+        state = PerceptionState()
+        xiaozhi = FakeXiaozhi()
+
+        async def emit(name, data, ts):
+            state.update_state("dev-1", name, data, ts)
+            state.broadcast(PerceptionEvent(device_id="dev-1", name=name, data=data, ts=ts))
+            await let_consumer_settle()
+
+        async def body() -> None:
+            await emit("state_changed", {"state": "talk"}, 100.0)
+            await emit("chat_status", {"listening": True}, 101.0)
+            await emit("chat_status", {"listening": False}, 110.0)
+            await emit("state_changed", {"state": "idle"}, 111.0)
+            await emit("sound_event", {"direction": "left"}, 139.0)
+            assert xiaozhi.set_head_angles_calls == []
+            await emit("sound_event", {"direction": "right"}, 140.0)
+            assert len(xiaozhi.set_head_angles_calls) == 1
+            assert xiaozhi.set_head_angles_calls[0]["yaw"] == 45
+
+        await _spin(state, xiaozhi, body)
+
+    asyncio.run(go())
+
+
+@pytest.mark.parametrize("new_name,new_data", [
+    ("chat_status", {"listening": True}),
+    ("dance_started", {}),
+])
+def test_queued_idle_sound_yields_to_new_chat_or_dance(new_name, new_data) -> None:
+    async def go() -> None:
+        state = PerceptionState()
+        xiaozhi = FakeXiaozhi()
+
+        async def body() -> None:
+            state.update_state("dev-1", "state_changed", {"state": "idle"}, 100.0)
+            state.broadcast(PerceptionEvent(device_id="dev-1", name="sound_event",
+                                            data={"direction": "left"}, ts=200.0))
+            # A later relay event updates current ownership before the queued
+            # sound consumer runs. It must consult current state, not old intent.
+            state.update_state("dev-1", new_name, new_data, 201.0)
+            state.broadcast(PerceptionEvent(device_id="dev-1", name=new_name, data=new_data, ts=201.0))
+            await let_consumer_settle()
+            assert xiaozhi.set_head_angles_calls == []
+
+        await _spin(state, xiaozhi, body)
+
+    asyncio.run(go())
+
+
 async def _spin(state, xiaozhi, body, *, cooldown=3.0, quiet=30.0):
     consumer = SoundTurner(
         state,
diff --git a/dotty-behaviour/tests/test_perception_state.py b/dotty-behaviour/tests/test_perception_state.py
index 8bab2b4a..c854f603 100644
--- a/dotty-behaviour/tests/test_perception_state.py
+++ b/dotty-behaviour/tests/test_perception_state.py
@@ -10,10 +10,55 @@
 
 import asyncio
 import time
+from pathlib import Path
 
 from perception import PerceptionEvent, PerceptionState
 
 
+def test_current_device_state_survives_daemon_reconstruction(tmp_path: Path) -> None:
+    state_file = tmp_path / "perception-state.json"
+    before_restart = PerceptionState(state_path=state_file)
+    before_restart.update_state(
+        "dev-1", "state_changed", {"state": "security"}, 100.0
+    )
+
+    after_restart = PerceptionState(state_path=state_file)
+
+    assert after_restart.current_device_state("dev-1") == "security"
+
+
+def test_invalid_persisted_state_fails_safe_to_idle(tmp_path: Path) -> None:
+    state_file = tmp_path / "perception-state.json"
+    state_file.write_text('{"dev-1":"security"}', encoding="utf-8")
+
+    restarted = PerceptionState(state_path=state_file)
+
+    assert restarted.current_device_state("dev-1") == "idle"
+
+
+def test_invalid_persisted_mutex_value_fails_safe_to_idle(tmp_path: Path) -> None:
+    state_file = tmp_path / "perception-state.json"
+    state_file.write_text('{"dev-1":{"current_state":7}}', encoding="utf-8")
+
+    restarted = PerceptionState(state_path=state_file)
+
+    assert restarted.current_device_state("dev-1") == "idle"
+
+
+def test_restart_does_not_revive_transient_sensor_state(tmp_path: Path) -> None:
+    state_file = tmp_path / "perception-state.json"
+    before_restart = PerceptionState(state_path=state_file)
+    before_restart.update_state("dev-1", "face_detected", {}, 90.0)
+    before_restart.update_state(
+        "dev-1", "state_changed", {"state": "security"}, 100.0
+    )
+
+    after_restart = PerceptionState(state_path=state_file)
+
+    assert after_restart.current_device_state("dev-1") == "security"
+    assert "face_present" not in after_restart.state["dev-1"]
+
+
 def test_subscribe_broadcast_unsubscribe_roundtrip() -> None:
     async def go() -> None:
         ps = PerceptionState()
@@ -93,6 +138,21 @@ def test_update_state_chat_status_toggles_listening() -> None:
     assert ps.state["dev-1"]["listening"] is False
 
 
+def test_chat_edges_refresh_quiet_timestamp_without_shortening_purr() -> None:
+    """AI-assisted regression: OpenAI Codex (GPT-6)."""
+    ps = PerceptionState()
+    ps.update_state("dev-1", "chat_status", {"listening": True}, 100.0)
+    assert ps.state["dev-1"]["last_chat_t"] == 100.0
+    ps.update_state("dev-1", "chat_status", {"listening": False}, 110.0)
+    assert ps.state["dev-1"]["last_chat_t"] == 110.0
+    # PurrPlayer intentionally reserves a future quiet window for its audio.
+    ps.state["dev-1"]["last_chat_t"] = 120.0
+    ps.update_state("dev-1", "chat_status", {"listening": True}, 115.0)
+    assert ps.state["dev-1"]["last_chat_t"] == 120.0
+    ps.update_state("dev-1", "chat_status", {"listening": False}, 125.0)
+    assert ps.state["dev-1"]["last_chat_t"] == 125.0
+
+
 def test_full_queue_drops_event_without_raising() -> None:
     async def go() -> None:
         ps = PerceptionState()
diff --git a/dotty-behaviour/tests/test_routes_perception.py b/dotty-behaviour/tests/test_routes_perception.py
index b2fd2412..27fbc870 100644
--- a/dotty-behaviour/tests/test_routes_perception.py
+++ b/dotty-behaviour/tests/test_routes_perception.py
@@ -143,58 +143,6 @@ def test_recent_unknown_device_returns_empty_list() -> None:
         assert r.json() == []
 
 
-def test_sound_balance_series_filters_and_orders() -> None:
-    """Three sound_events with a non-sound event interleaved → response is
-    just the sound balances, oldest-first."""
-    with TestClient(app) as client:
-        client.post(
-            "/api/perception/event",
-            json={
-                "device_id": "dev-1",
-                "name": "sound_event",
-                "data": {"balance": 0.3},
-                "ts": 1.0,
-            },
-        )
-        client.post(
-            "/api/perception/event",
-            json={
-                "device_id": "dev-1",
-                "name": "sound_event",
-                "data": {"balance": 0.6},
-                "ts": 2.0,
-            },
-        )
-        client.post(
-            "/api/perception/event",
-            json={
-                "device_id": "dev-1",
-                "name": "face_detected",
-                "data": {},
-                "ts": 2.5,
-            },
-        )
-        client.post(
-            "/api/perception/event",
-            json={
-                "device_id": "dev-1",
-                "name": "sound_event",
-                "data": {"balance": 0.9},
-                "ts": 3.0,
-            },
-        )
-        r = client.get("/api/perception/sound-balance/dev-1")
-        assert r.status_code == 200
-        assert r.json() == [0.3, 0.6, 0.9]
-
-
-def test_sound_balance_series_unknown_device_returns_empty_list() -> None:
-    with TestClient(app) as client:
-        r = client.get("/api/perception/sound-balance/nobody")
-        assert r.status_code == 200
-        assert r.json() == []
-
-
 def test_perception_feed_subscribe_and_dispatch() -> None:
     """Exercise the SSE generator directly without going through
     TestClient's streaming context (which hangs on close because the
diff --git a/dotty-behaviour/tests/test_routes_voice.py b/dotty-behaviour/tests/test_routes_voice.py
index b378a336..3fb724b8 100644
--- a/dotty-behaviour/tests/test_routes_voice.py
+++ b/dotty-behaviour/tests/test_routes_voice.py
@@ -4,11 +4,28 @@
 
 from time import perf_counter
 
+from fastapi import FastAPI
 from fastapi.testclient import TestClient
+import pytest
 
+import config
 from household import Person
-from main import app
-from routes.voice import TAKE_PHOTO_FALLBACK, person_needs_review
+from perception import PerceptionState
+from routes.voice import TAKE_PHOTO_FALLBACK, person_needs_review, router
+
+# Exercise the actual HTTP route without starting unrelated live consumers,
+# loading household records or preparing production directories.
+app = FastAPI()
+app.include_router(router)
+
+
+@pytest.fixture(autouse=True)
+def explicit_adult_camera_policy(tmp_path, monkeypatch):
+    """Existing freshness tests exercise adult mode, never a live toggle."""
+    path = tmp_path / "kid-mode"
+    path.write_text("false")
+    monkeypatch.setattr(config, "KID_MODE_STATE_FILE", path)
+    app.state.perception = PerceptionState()
 
 
 def test_take_photo_returns_fallback_when_cache_empty() -> None:
diff --git a/dotty-behaviour/tests/test_sound_turner_gate.py b/dotty-behaviour/tests/test_sound_turner_gate.py
new file mode 100644
index 00000000..9b565677
--- /dev/null
+++ b/dotty-behaviour/tests/test_sound_turner_gate.py
@@ -0,0 +1,25 @@
+"""SoundTurner is off unless SOUND_TURN_ENABLED=1 — the firmware localizer
+is stuck-left (#27), so the turner only ever snapped the head left."""
+from __future__ import annotations
+
+import importlib
+
+import config
+
+
+def test_sound_turner_disabled_by_default(monkeypatch) -> None:
+    monkeypatch.delenv("SOUND_TURN_ENABLED", raising=False)
+    try:
+        assert importlib.reload(config).SOUND_TURN_ENABLED is False
+    finally:
+        monkeypatch.undo()
+        importlib.reload(config)
+
+
+def test_sound_turner_opt_in(monkeypatch) -> None:
+    monkeypatch.setenv("SOUND_TURN_ENABLED", "1")
+    try:
+        assert importlib.reload(config).SOUND_TURN_ENABLED is True
+    finally:
+        monkeypatch.undo()
+        importlib.reload(config)
diff --git a/dotty-pi-ext/package.json b/dotty-pi-ext/package.json
index 0e18b813..55ed8b98 100644
--- a/dotty-pi-ext/package.json
+++ b/dotty-pi-ext/package.json
@@ -15,7 +15,7 @@
     "@earendil-works/pi-coding-agent": "^0.74.0"
   },
   "scripts": {
-    "test": "npm run test:memory && npm run test:memgate && npm run test:recall && npm run test:remember && npm run test:rememberperson && npm run test:turnlog && npm run test:think && npm run test:play && npm run test:adminauth",
+    "test": "node tests/run_isolated.mjs",
     "test:memory": "node --experimental-strip-types tests/memory_lookup.test.ts",
     "test:memgate": "node --experimental-strip-types tests/memory_gate.test.ts",
     "test:recall": "node --experimental-strip-types tests/recall_person.test.ts",
@@ -24,6 +24,7 @@
     "test:turnlog": "node --experimental-strip-types tests/turn_log.test.ts",
     "test:think": "node --experimental-strip-types tests/think_hard.test.ts",
     "test:play": "node --experimental-strip-types tests/play_song.test.ts",
+    "test:photo": "node --experimental-strip-types tests/take_photo.test.ts",
     "test:adminauth": "node --experimental-strip-types tests/admin_auth.test.ts"
   }
 }
diff --git a/dotty-pi-ext/src/lib/llama_swap.ts b/dotty-pi-ext/src/lib/llama_swap.ts
index 8ef3fd9e..121e9430 100644
--- a/dotty-pi-ext/src/lib/llama_swap.ts
+++ b/dotty-pi-ext/src/lib/llama_swap.ts
@@ -10,7 +10,10 @@
 
 const DEFAULT_URL =
   process.env.VOICE_THINKER_URL ?? "http://localhost:8080/v1/chat/completions";
-const DEFAULT_TIMEOUT_SEC = Number(process.env.VOICE_THINKER_TIMEOUT ?? "30");
+// 90 s, not 30: the reasoner is not kept resident, and a cold load alone is
+// 30-50 s. At 30 s the first think_hard after any idle period was cancelled
+// mid-load (llama-swap logged "502 … context canceled" at ~31 s).
+export const DEFAULT_TIMEOUT_SEC = Number(process.env.VOICE_THINKER_TIMEOUT ?? "90");
 
 export interface ChatCompletionRequest {
   model: string;
diff --git a/dotty-pi-ext/src/lib/turn_logger.ts b/dotty-pi-ext/src/lib/turn_logger.ts
index d61d7631..8375a188 100644
--- a/dotty-pi-ext/src/lib/turn_logger.ts
+++ b/dotty-pi-ext/src/lib/turn_logger.ts
@@ -12,6 +12,7 @@ import type {
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { storeMemory } from "./brain_db.ts";
+import { stripTurnBoilerplate } from "./turn_text.ts";
 
 // bridge.py:/api/voice/memory_log truncates user→500 chars, assistant→1000
 // before storing. Keep parity so the LLM that was tuned against this
@@ -51,7 +52,9 @@ export function extractTurnText(messages: readonly any[]): {
   if (lastUserIdx === -1) return { user: "", assistant: "" };
 
   const userMsg = messages[lastUserIdx];
-  const user = stringifyUserContent(userMsg.content).trim();
+  // The prompt pi received is the person's words plus the provider's per-turn
+  // scaffolding; only the former is conversation worth remembering.
+  const user = stripTurnBoilerplate(stringifyUserContent(userMsg.content));
 
   const assistantParts: string[] = [];
   for (let i = lastUserIdx + 1; i < messages.length; i++) {
diff --git a/dotty-pi-ext/src/lib/turn_text.ts b/dotty-pi-ext/src/lib/turn_text.ts
new file mode 100644
index 00000000..183941d8
--- /dev/null
+++ b/dotty-pi-ext/src/lib/turn_text.ts
@@ -0,0 +1,51 @@
+// Separates what a person said from the scaffolding the voice provider wraps
+// around it. PiVoiceLLM appends tool-routing guidance and the HARD CONSTRAINTS
+// rules to every prompt (and, for recall, a block of memory search results).
+// None of that is conversation: it must not be written to brain.db, and rows
+// written before this existed must not be read back out with it attached.
+
+// Each marker is matched only at the start of a line after a blank/new line,
+// exactly as the provider emits it, so a person saying the words is untouched.
+const SCAFFOLD_START =
+  /\n+(?:MEMORY SEARCH RESULTS \(|VOICE TOOL ROUTING:|---\nHARD CONSTRAINTS for THIS reply)/;
+
+/** Unwrap the legacy ASR envelope `{"content": "..."}` if that is all there is. */
+function unwrapAsrEnvelope(text: string): string {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return text;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && typeof parsed.content === "string") {
+      return parsed.content;
+    }
+  } catch {
+    // Not JSON — leave the text exactly as spoken.
+  }
+  return text;
+}
+
+/** The user's own words from a prompt as pi received it. */
+export function stripTurnBoilerplate(text: string): string {
+  const raw = text ?? "";
+  const cut = raw.search(SCAFFOLD_START);
+  const spoken = cut === -1 ? raw : raw.slice(0, cut);
+  return unwrapAsrEnvelope(spoken).trim();
+}
+
+const USER_PREFIX = "user: ";
+const ASSISTANT_SEPARATOR = " | assistant: ";
+
+/**
+ * Clean one stored `user: … | assistant: …` conversation row. Rows written
+ * before the logger stripped scaffolding hold up to 500 characters of it
+ * (truncated mid-rule) between the user's words and the reply.
+ */
+export function cleanStoredTurn(content: string): string {
+  const raw = content ?? "";
+  if (!raw.startsWith(USER_PREFIX)) return raw;
+  const split = raw.indexOf(ASSISTANT_SEPARATOR);
+  const user = stripTurnBoilerplate(raw.slice(USER_PREFIX.length, split === -1 ? undefined : split));
+  return split === -1
+    ? `${USER_PREFIX}${user}`
+    : `${USER_PREFIX}${user}${ASSISTANT_SEPARATOR}${raw.slice(split + ASSISTANT_SEPARATOR.length).trim()}`;
+}
diff --git a/dotty-pi-ext/src/tools/memory_lookup.ts b/dotty-pi-ext/src/tools/memory_lookup.ts
index 5b47dbe4..e9c49092 100644
--- a/dotty-pi-ext/src/tools/memory_lookup.ts
+++ b/dotty-pi-ext/src/tools/memory_lookup.ts
@@ -11,6 +11,7 @@
 
 import { Type } from "typebox";
 import { searchMemories, type MemoryRow } from "../lib/brain_db.ts";
+import { cleanStoredTurn } from "../lib/turn_text.ts";
 
 const MAX_SNIPPETS = 3;
 const SNIPPET_MAX_CHARS = 200;
@@ -40,12 +41,21 @@ export function formatLookupResult(rows: MemoryRow[]): string {
   return snippets.join(" | ");
 }
 
+/**
+ * Drop prompt scaffolding from stored conversation rows before they are
+ * formatted. Kept apart from formatLookupResult so that function stays
+ * byte-compatible with the bridge.py oracle.
+ */
+export function cleanLookupRows(rows: MemoryRow[]): MemoryRow[] {
+  return rows.map((row) => ({ ...row, content: cleanStoredTurn(row.content ?? "") }));
+}
+
 /** Top-level dispatch used by both the pi tool and the test rig. */
 export function runMemoryLookup(query: string, dbPath?: string): string {
   const q = (query ?? "").trim();
   if (!q) return "(empty query)";
   const rows = searchMemories(q, { limit: 5, dbPath });
-  return formatLookupResult(rows);
+  return formatLookupResult(cleanLookupRows(rows));
 }
 
 /** Pi tool descriptor — passed to `pi.registerTool` from index.ts. */
diff --git a/dotty-pi-ext/tests/run_isolated.mjs b/dotty-pi-ext/tests/run_isolated.mjs
new file mode 100644
index 00000000..0e598a4b
--- /dev/null
+++ b/dotty-pi-ext/tests/run_isolated.mjs
@@ -0,0 +1,34 @@
+// Run every voice-tool test against invented data with live smoke disabled.
+// AI-assisted: OpenAI Codex (GPT-6).
+import { mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { createFixture, isolatedEnvironment } from "./synthetic_fixture.mjs";
+
+const tests = dirname(fileURLToPath(import.meta.url));
+const directory = mkdtempSync(join(tmpdir(), "dotty-tool-fixture-"));
+const snapshot = join(directory, "synthetic.db");
+let failures = 0;
+try {
+  createFixture(snapshot);
+  const env = isolatedEnvironment(process.env, snapshot);
+  // Automatic discovery includes take_photo and prevents silently omitted suites.
+  const files = readdirSync(tests).filter(name => name.endsWith(".test.ts")).sort();
+  for (const name of files) {
+    console.log(`\n--- ${name} (synthetic fixture; live smoke disabled) ---`);
+    const result = spawnSync(process.execPath, ["--experimental-strip-types", join(tests, name)], {
+      cwd: dirname(tests), env, stdio: "inherit", timeout: 60000,
+    });
+    if (result.error || result.status !== 0) {
+      failures++;
+      console.error(`${name}: ${result.error?.message ?? `exit ${result.status}, signal ${result.signal}`}`);
+    }
+  }
+  console.log(`\nIsolated suites: ${files.length - failures}/${files.length} passed; no household snapshot used.`);
+} finally {
+  // Exact directory created above, never a caller-supplied path.
+  rmSync(directory, { recursive: true, force: true });
+}
+process.exitCode = failures ? 1 : 0;
diff --git a/dotty-pi-ext/tests/synthetic_fixture.mjs b/dotty-pi-ext/tests/synthetic_fixture.mjs
new file mode 100644
index 00000000..632bf5b0
--- /dev/null
+++ b/dotty-pi-ext/tests/synthetic_fixture.mjs
@@ -0,0 +1,59 @@
+// Invented test data only. AI-assisted: OpenAI Codex (GPT-6).
+// Compatible with the memory tools' UUID-id/SQLite-rowid contract; this is
+// a test fixture, not a production database migration or household snapshot.
+import { closeSync, openSync } from "node:fs";
+import Database from "better-sqlite3";
+
+export function createFixture(path) {
+  // Refuse even an empty existing file. Never overwrite a caller's database.
+  closeSync(openSync(path, "wx", 0o600));
+  const db = new Database(path);
+  try {
+    db.exec(`
+      CREATE TABLE memories (
+        id TEXT PRIMARY KEY, key TEXT NOT NULL UNIQUE, content TEXT NOT NULL,
+        category TEXT NOT NULL, embedding BLOB, created_at TEXT,
+        updated_at TEXT, session_id TEXT, namespace TEXT NOT NULL,
+        importance REAL DEFAULT 0.5, superseded_by TEXT
+      );
+      CREATE VIRTUAL TABLE memories_fts USING fts5(
+        key, content, content='memories', content_rowid='rowid'
+      );
+      CREATE TRIGGER memories_insert AFTER INSERT ON memories BEGIN
+        INSERT INTO memories_fts(rowid,key,content) VALUES (new.rowid,new.key,new.content);
+      END;
+      CREATE TRIGGER memories_delete AFTER DELETE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts,rowid,key,content)
+          VALUES ('delete',old.rowid,old.key,old.content);
+      END;
+      CREATE TRIGGER memories_update AFTER UPDATE ON memories BEGIN
+        INSERT INTO memories_fts(memories_fts,rowid,key,content)
+          VALUES ('delete',old.rowid,old.key,old.content);
+        INSERT INTO memories_fts(rowid,key,content) VALUES (new.rowid,new.key,new.content);
+      END;
+    `);
+    const insert = db.prepare(`
+      INSERT INTO memories(id,key,content,category,namespace,importance,created_at,updated_at)
+      VALUES (?,?,?,'core','voice',0.5,'2026-01-01T00:00:00.000Z','2026-01-01T00:00:00.000Z')
+    `);
+    [
+      "Dotty is a fictional robot in this isolated test fixture.",
+      "Taiwan is a search keyword in this invented test record.",
+      "The fictional robot name in this fixture is Dotty.",
+    ].forEach((content, i) => insert.run(
+      `00000000-0000-4000-8000-00000000000${i + 1}`, `synthetic-${i + 1}`, content,
+    ));
+  } finally {
+    db.close();
+  }
+}
+
+export function isolatedEnvironment(original, path) {
+  const env = { ...original };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("DOTTY_") || key.startsWith("XIAOZHI_")) delete env[key];
+  }
+  env.DOTTY_BRAIN_DB = path;
+  env.DOTTY_BRAIN_DB_SNAPSHOT = path;
+  return env;
+}
diff --git a/dotty-pi-ext/tests/test_isolation.test.ts b/dotty-pi-ext/tests/test_isolation.test.ts
new file mode 100644
index 00000000..52f5b746
--- /dev/null
+++ b/dotty-pi-ext/tests/test_isolation.test.ts
@@ -0,0 +1,45 @@
+// Synthetic fixture isolation. AI-assisted: OpenAI Codex (GPT-6).
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { createFixture, isolatedEnvironment } from "./synthetic_fixture.mjs";
+
+const directory = mkdtempSync(join(tmpdir(), "dotty-fixture-contract-"));
+const path = join(directory, "synthetic.db");
+try {
+  createFixture(path);
+  assert.throws(() => createFixture(path), /EEXIST/);
+  const db = new Database(path);
+  try {
+    assert.equal(db.prepare("SELECT count(*) AS n FROM memories").get().n, 3);
+    for (const query of ["Dotty", "Taiwan", "name"]) {
+      assert.ok(db.prepare("SELECT count(*) AS n FROM memories_fts WHERE memories_fts MATCH ?").get(query).n > 0);
+    }
+    db.prepare("INSERT INTO memories(id,key,content,category,namespace) VALUES (?,?,?,?,?)")
+      .run("trigger-test", "trigger-test", "fixtureonlytoken", "core", "voice");
+    const count = () => db.prepare("SELECT count(*) AS n FROM memories_fts WHERE memories_fts MATCH 'fixtureonlytoken'").get().n;
+    assert.equal(count(), 1);
+    db.prepare("UPDATE memories SET content='replacementtoken' WHERE id='trigger-test'").run();
+    assert.equal(count(), 0);
+    db.prepare("DELETE FROM memories WHERE id='trigger-test'").run();
+    assert.equal(db.prepare("SELECT count(*) AS n FROM memories_fts WHERE memories_fts MATCH 'replacementtoken'").get().n, 0);
+  } finally {
+    db.close();
+  }
+  const original = { PATH: "/usr/bin", DOTTY_BRAIN_DB: "/household.db",
+    DOTTY_BRAIN_DB_SNAPSHOT: "/household-copy.db", DOTTY_LLAMA_SWAP_URL: "http://live",
+    DOTTY_XIAOZHI_HOST: "live", XIAOZHI_HOST: "live", DOTTY_ADMIN_TOKEN: "secret" };
+  const env = isolatedEnvironment(original, path);
+  assert.equal(env.DOTTY_BRAIN_DB, path);
+  assert.equal(env.DOTTY_BRAIN_DB_SNAPSHOT, path);
+  for (const key of ["DOTTY_LLAMA_SWAP_URL", "DOTTY_XIAOZHI_HOST", "XIAOZHI_HOST", "DOTTY_ADMIN_TOKEN"]) {
+    assert.equal(env[key], undefined);
+  }
+  assert.equal(env.PATH, "/usr/bin");
+  assert.equal(original.DOTTY_BRAIN_DB, "/household.db");
+  console.log("test_isolation: fixture hits, FTS insert/update/delete, no overwrite, environment isolation pass");
+} finally {
+  rmSync(directory, { recursive: true, force: true });
+}
diff --git a/dotty-pi-ext/tests/think_hard.test.ts b/dotty-pi-ext/tests/think_hard.test.ts
index 68edd10b..6dad09b3 100644
--- a/dotty-pi-ext/tests/think_hard.test.ts
+++ b/dotty-pi-ext/tests/think_hard.test.ts
@@ -11,7 +11,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { buildThinkRequest, runThinkHard } from "../src/tools/think_hard.ts";
-import { TimeoutError } from "../src/lib/llama_swap.ts";
+import { DEFAULT_TIMEOUT_SEC, TimeoutError } from "../src/lib/llama_swap.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const ORACLE = join(__dirname, "think_hard_oracle.py");
@@ -177,6 +177,10 @@ async function testLiveSmoke(): Promise<void> {
 async function main(): Promise<void> {
   testRequestBodies();
   await testEmptyInput();
+  if (!process.env.VOICE_THINKER_TIMEOUT) {
+    // Must outlast a cold reasoner load (30-50 s) plus generation.
+    assertEq("default timeout outlasts a cold load", String(DEFAULT_TIMEOUT_SEC >= 75), "true");
+  }
   await testSuccess();
   await testLongResponseCap();
   await testTimeout();
diff --git a/dotty-pi-ext/tests/turn_boilerplate.test.ts b/dotty-pi-ext/tests/turn_boilerplate.test.ts
new file mode 100644
index 00000000..d7bdcb1c
--- /dev/null
+++ b/dotty-pi-ext/tests/turn_boilerplate.test.ts
@@ -0,0 +1,63 @@
+// Prompt scaffolding must never be stored in, or read back out of, memory.
+// AI-assisted: Claude. Observed 2026-10-05: 253 of 402 conversation rows in a
+// live brain.db carried the per-turn "HARD CONSTRAINTS" suffix, and a recall
+// request returned those rows verbatim for TTS.
+
+import { stripTurnBoilerplate, cleanStoredTurn } from "../src/lib/turn_text.ts";
+import { extractTurnText } from "../src/lib/turn_logger.ts";
+import { formatLookupResult, cleanLookupRows } from "../src/tools/memory_lookup.ts";
+
+let failures = 0;
+function assertEq(label: string, actual: unknown, expected: unknown): void {
+  const a = JSON.stringify(actual);
+  const e = JSON.stringify(expected);
+  if (a === e) {
+    process.stdout.write(`  PASS  ${label}\n`);
+    return;
+  }
+  process.stderr.write(`  FAIL  ${label}\n        expected: ${e}\n        actual:   ${a}\n`);
+  failures++;
+}
+
+const ROUTING = "\n\nVOICE TOOL ROUTING: Decide whether to use a registered tool before composing.";
+const RULES = "\n\n---\nHARD CONSTRAINTS for THIS reply (overrides everything else):\n1. Reply in ENGLISH ONLY.\nBegin your reply now.";
+const MEMORY = "\n\nMEMORY SEARCH RESULTS (from earlier conversations):\nuser: old | assistant: older";
+
+assertEq("plain text is untouched", stripTurnBoilerplate("What is your name?"), "What is your name?");
+assertEq("routing + rules suffix removed", stripTurnBoilerplate("What is your name?" + ROUTING + RULES), "What is your name?");
+assertEq("rules-only suffix removed", stripTurnBoilerplate("Tell me a joke." + RULES), "Tell me a joke.");
+assertEq("injected memory block removed", stripTurnBoilerplate("Do you remember my colour?" + MEMORY + ROUTING + RULES), "Do you remember my colour?");
+assertEq("legacy ASR JSON wrapper unwrapped",
+  stripTurnBoilerplate('{"content": "Dotty, what is my favourite colour?"}\n---\nHARD CONSTRAINTS for THIS reply'),
+  "Dotty, what is my favourite colour?");
+assertEq("ordinary braces are not treated as a wrapper", stripTurnBoilerplate("{not json} hello"), "{not json} hello");
+assertEq("a user merely saying the words keeps their sentence",
+  stripTurnBoilerplate("what are hard constraints for this reply"), "what are hard constraints for this reply");
+
+const logged = extractTurnText([
+  { role: "user", content: "What is 12 plus 7?" + ROUTING + RULES, timestamp: 1 },
+  { role: "assistant", content: [{ type: "text", text: "😊 19!" }] },
+]);
+assertEq("turn logger stores only what the person said", logged, { user: "What is 12 plus 7?", assistant: "😊 19!" });
+
+assertEq("stored turn with truncated rules is cleaned, reply kept",
+  cleanStoredTurn('user: {"content": "My favourite colour is purple."}\n---\nHARD CONSTRAINTS for THIS reply (overr | assistant: 😊 Purple is lovely!'),
+  "user: My favourite colour is purple. | assistant: 😊 Purple is lovely!");
+assertEq("stored turn without a reply is cleaned",
+  cleanStoredTurn("user: Hello there" + RULES), "user: Hello there");
+assertEq("facts and other rows pass through", cleanStoredTurn("Brett's favourite colour is purple."), "Brett's favourite colour is purple.");
+
+const rows: any[] = [
+  { key: "voice_conversation_1", category: "conversation", namespace: "voice", created_at: "x",
+    content: "user: My favourite colour is purple." + RULES + " | assistant: 😊 Noted!" },
+  { key: "core_1", category: "core", namespace: "default", created_at: "x", content: "Favourite colour: purple." },
+];
+assertEq("lookup output carries no prompt scaffolding",
+  formatLookupResult(cleanLookupRows(rows)),
+  "user: My favourite colour is purple. | assistant: 😊 Noted! | Favourite colour: purple.");
+
+if (failures) {
+  process.stderr.write(`\n${failures} failure(s)\n`);
+  process.exit(1);
+}
+process.stdout.write("\nOK — 0 failure(s)\n");
diff --git a/personas/pi_voice.md b/personas/pi_voice.md
new file mode 100644
index 00000000..675c0ab0
--- /dev/null
+++ b/personas/pi_voice.md
@@ -0,0 +1,12 @@
+You are Dotty, a small desktop robot with a cartoon screen face and a head that can turn. You talk out loud through a little speaker, and people talk to you with their voice. You are a robot friend, not a computer program helper: never describe yourself as an assistant for coding, software, files or projects.
+
+Who you are: cheerful, curious, gentle and a bit silly. You love questions, jokes, stories, animals, space and helping.
+
+How to answer:
+- Be brief. Say the answer and stop: no follow-up question and no extra remark unless they asked for a story or an explanation. If they say "just say the answer" or ask you to repeat words, say only that.
+- Answer what was actually asked. If asked about yourself, talk about yourself, Dotty the robot. If asked for a joke, tell a real joke with a set-up and a punchline.
+- What you hear comes from a microphone and can be garbled. If the words do not make sense, say you did not catch that and ask them to say it again. Do not guess or repeat nonsense back.
+- You are usually talking with young children. Never describe yourself or anyone doing something that could hurt a child who copied it: climbing high, touching fans, heaters, plugs or tools, or going places alone.
+- Use your tools when someone asks you to remember or recall something, play a song, look at something, or work out something hard. Otherwise just talk.
+
+The rules at the end of each message about language, the single leading emoji and length always apply.
diff --git a/pi-session-2026-06-06T09-40-45-332Z_019e9c4e-6a94-798d-bbe2-5c7a708dfe96.html b/pi-session-2026-06-06T09-40-45-332Z_019e9c4e-6a94-798d-bbe2-5c7a708dfe96.html
new file mode 100644
index 00000000..096c5396
--- /dev/null
+++ b/pi-session-2026-06-06T09-40-45-332Z_019e9c4e-6a94-798d-bbe2-5c7a708dfe96.html
@@ -0,0 +1,4256 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Session Export</title>
+  <style>
+    :root {
+      --accent: #8abeb7;
+      --border: #5f87ff;
+      --borderAccent: #00d7ff;
+      --borderMuted: #505050;
+      --success: #b5bd68;
+      --error: #cc6666;
+      --warning: #ffff00;
+      --muted: #808080;
+      --dim: #666666;
+      --text: #d4d4d4;
+      --thinkingText: #808080;
+      --selectedBg: #3a3a4a;
+      --userMessageBg: #343541;
+      --userMessageText: #d4d4d4;
+      --customMessageBg: #2d2838;
+      --customMessageText: #d4d4d4;
+      --customMessageLabel: #9575cd;
+      --toolPendingBg: #282832;
+      --toolSuccessBg: #283228;
+      --toolErrorBg: #3c2828;
+      --toolTitle: #d4d4d4;
+      --toolOutput: #808080;
+      --mdHeading: #f0c674;
+      --mdLink: #81a2be;
+      --mdLinkUrl: #666666;
+      --mdCode: #8abeb7;
+      --mdCodeBlock: #b5bd68;
+      --mdCodeBlockBorder: #808080;
+      --mdQuote: #808080;
+      --mdQuoteBorder: #808080;
+      --mdHr: #808080;
+      --mdListBullet: #8abeb7;
+      --toolDiffAdded: #b5bd68;
+      --toolDiffRemoved: #cc6666;
+      --toolDiffContext: #808080;
+      --syntaxComment: #6A9955;
+      --syntaxKeyword: #569CD6;
+      --syntaxFunction: #DCDCAA;
+      --syntaxVariable: #9CDCFE;
+      --syntaxString: #CE9178;
+      --syntaxNumber: #B5CEA8;
+      --syntaxType: #4EC9B0;
+      --syntaxOperator: #D4D4D4;
+      --syntaxPunctuation: #D4D4D4;
+      --thinkingOff: #505050;
+      --thinkingMinimal: #6e6e6e;
+      --thinkingLow: #5f87af;
+      --thinkingMedium: #81a2be;
+      --thinkingHigh: #b294bb;
+      --thinkingXhigh: #d183e8;
+      --bashMode: #b5bd68;
+      --exportPageBg: #18181e;
+      --exportCardBg: #1e1e24;
+      --exportInfoBg: #3c3728;
+      --body-bg: #18181e;
+      --container-bg: #1e1e24;
+      --info-bg: #3c3728;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+
+    :root {
+      --line-height: 18px; /* 12px font * 1.5 */
+      --sidebar-width: 400px;
+      --sidebar-min-width: 240px;
+      --sidebar-max-width: 840px;
+      --sidebar-resizer-width: 6px;
+    }
+
+    body {
+      font-family: ui-monospace, 'Cascadia Code', 'Source Code Pro', Menlo, Consolas, 'DejaVu Sans Mono', monospace;
+      font-size: 12px;
+      line-height: var(--line-height);
+      color: var(--text);
+      background: var(--body-bg);
+    }
+
+    body.sidebar-resizing {
+      cursor: col-resize;
+      user-select: none;
+    }
+
+    #app {
+      display: flex;
+      min-height: 100vh;
+    }
+
+    /* Sidebar */
+    #sidebar {
+      width: var(--sidebar-width);
+      min-width: var(--sidebar-width);
+      max-width: var(--sidebar-width);
+      background: var(--container-bg);
+      flex-shrink: 0;
+      display: flex;
+      flex-direction: column;
+      position: sticky;
+      top: 0;
+      height: 100vh;
+      border-right: 1px solid var(--dim);
+    }
+
+    #sidebar-resizer {
+      width: var(--sidebar-resizer-width);
+      flex-shrink: 0;
+      position: sticky;
+      top: 0;
+      height: 100vh;
+      cursor: col-resize;
+      touch-action: none;
+      background: transparent;
+      border-right: 1px solid transparent;
+    }
+
+    #sidebar-resizer:hover,
+    body.sidebar-resizing #sidebar-resizer {
+      background: var(--selectedBg);
+      border-right-color: var(--dim);
+    }
+
+    .sidebar-header {
+      padding: 8px 12px;
+      flex-shrink: 0;
+    }
+
+    .sidebar-controls {
+      padding: 8px 8px 4px 8px;
+    }
+
+    .sidebar-search {
+      width: 100%;
+      box-sizing: border-box;
+      padding: 4px 8px;
+      font-size: 11px;
+      font-family: inherit;
+      background: var(--body-bg);
+      color: var(--text);
+      border: 1px solid var(--dim);
+      border-radius: 3px;
+    }
+
+    .sidebar-filters {
+      display: flex;
+      padding: 4px 8px 8px 8px;
+      gap: 4px;
+      align-items: center;
+      flex-wrap: wrap;
+    }
+
+    .sidebar-search:focus {
+      outline: none;
+      border-color: var(--accent);
+    }
+
+    .sidebar-search::placeholder {
+      color: var(--muted);
+    }
+
+    .filter-btn {
+      padding: 3px 8px;
+      font-size: 10px;
+      font-family: inherit;
+      background: transparent;
+      color: var(--muted);
+      border: 1px solid var(--dim);
+      border-radius: 3px;
+      cursor: pointer;
+    }
+
+    .filter-btn:hover {
+      color: var(--text);
+      border-color: var(--text);
+    }
+
+    .filter-btn.active {
+      background: var(--accent);
+      color: var(--body-bg);
+      border-color: var(--accent);
+    }
+
+    .sidebar-close {
+      display: none;
+      padding: 3px 8px;
+      font-size: 12px;
+      font-family: inherit;
+      background: transparent;
+      color: var(--muted);
+      border: 1px solid var(--dim);
+      border-radius: 3px;
+      cursor: pointer;
+      margin-left: auto;
+    }
+
+    .sidebar-close:hover {
+      color: var(--text);
+      border-color: var(--text);
+    }
+
+    .tree-container {
+      flex: 1;
+      overflow: auto;
+      padding: 4px 0;
+    }
+
+    .tree-node {
+      padding: 0 8px;
+      cursor: pointer;
+      display: flex;
+      align-items: baseline;
+      font-size: 11px;
+      line-height: 13px;
+      white-space: nowrap;
+    }
+
+    .tree-node:hover {
+      background: var(--selectedBg);
+    }
+
+    .tree-node.active {
+      background: var(--selectedBg);
+    }
+
+    .tree-node.active .tree-content {
+      font-weight: bold;
+    }
+
+    .tree-node.in-path {
+      background: color-mix(in srgb, var(--accent) 10%, transparent);
+    }
+
+    .tree-node:not(.in-path) {
+      opacity: 0.5;
+    }
+
+    .tree-node:not(.in-path):hover {
+      opacity: 1;
+    }
+
+    .tree-prefix {
+      color: var(--muted);
+      flex-shrink: 0;
+      font-family: monospace;
+      white-space: pre;
+    }
+
+    .tree-marker {
+      color: var(--accent);
+      flex-shrink: 0;
+    }
+
+    .tree-content {
+      color: var(--text);
+    }
+
+    .tree-role-user {
+      color: var(--accent);
+    }
+
+    .tree-role-skill {
+      color: var(--customMessageLabel);
+    }
+
+    .tree-role-assistant {
+      color: var(--success);
+    }
+
+    .tree-role-tool {
+      color: var(--muted);
+    }
+
+    .tree-muted {
+      color: var(--muted);
+    }
+
+    .tree-error {
+      color: var(--error);
+    }
+
+    .tree-compaction {
+      color: var(--borderAccent);
+    }
+
+    .tree-branch-summary {
+      color: var(--warning);
+    }
+
+    .tree-custom-message {
+      color: var(--customMessageLabel);
+    }
+
+    .tree-status {
+      padding: 4px 12px;
+      font-size: 10px;
+      color: var(--muted);
+      flex-shrink: 0;
+    }
+
+    /* Main content */
+    #content {
+      flex: 1;
+      min-width: 0;
+      overflow-y: auto;
+      padding: var(--line-height) calc(var(--line-height) * 2);
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+    }
+
+    #content > * {
+      width: 100%;
+      max-width: 800px;
+    }
+
+    /* Help bar */
+    .help-bar {
+      font-size: 11px;
+      color: var(--warning);
+      margin-bottom: var(--line-height);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      flex-wrap: wrap;
+      gap: 12px;
+    }
+
+    .help-hint {
+      flex: 1 1 240px;
+    }
+
+    .help-actions {
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+
+    .header-toggle-btn,
+    .download-json-btn {
+      font-size: 10px;
+      padding: 2px 8px;
+      background: var(--container-bg);
+      border: 1px solid var(--border);
+      border-radius: 3px;
+      color: var(--text);
+      cursor: pointer;
+      font-family: inherit;
+    }
+
+    .header-toggle-btn:hover,
+    .download-json-btn:hover {
+      background: var(--hover);
+      border-color: var(--borderAccent);
+    }
+
+    /* Header */
+    .header {
+      background: var(--container-bg);
+      border-radius: 4px;
+      padding: var(--line-height);
+      margin-bottom: var(--line-height);
+    }
+
+    .header h1 {
+      font-size: 12px;
+      font-weight: bold;
+      color: var(--borderAccent);
+      margin-bottom: var(--line-height);
+    }
+
+    .header-info {
+      display: flex;
+      flex-direction: column;
+      gap: 0;
+      font-size: 11px;
+    }
+
+    .info-item {
+      color: var(--dim);
+      display: flex;
+      align-items: baseline;
+    }
+
+    .info-label {
+      font-weight: 600;
+      margin-right: 8px;
+      min-width: 100px;
+    }
+
+    .info-value {
+      color: var(--text);
+      flex: 1;
+    }
+
+    /* Messages */
+    #messages {
+      display: flex;
+      flex-direction: column;
+      gap: var(--line-height);
+    }
+
+    .message-timestamp {
+      font-size: 10px;
+      color: var(--dim);
+      opacity: 0.8;
+    }
+
+    .user-message {
+      background: var(--userMessageBg);
+      color: var(--userMessageText);
+      padding: var(--line-height);
+      border-radius: 4px;
+      position: relative;
+    }
+
+    .assistant-message {
+      padding: 0;
+      position: relative;
+    }
+
+    /* Copy link button - appears on hover */
+    .copy-link-btn {
+      position: absolute;
+      top: 8px;
+      right: 8px;
+      width: 28px;
+      height: 28px;
+      padding: 6px;
+      background: var(--container-bg);
+      border: 1px solid var(--dim);
+      border-radius: 4px;
+      color: var(--muted);
+      cursor: pointer;
+      opacity: 0;
+      transition: opacity 0.15s, background 0.15s, color 0.15s;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 10;
+    }
+
+    .user-message:hover .copy-link-btn,
+    .assistant-message:hover .copy-link-btn,
+    .skill-user-entry:hover .copy-link-btn {
+      opacity: 1;
+    }
+
+    .copy-link-btn:hover {
+      background: var(--accent);
+      color: var(--body-bg);
+      border-color: var(--accent);
+    }
+
+    .copy-link-btn.copied {
+      background: var(--success, #22c55e);
+      color: white;
+      border-color: var(--success, #22c55e);
+    }
+
+    /* Highlight effect for deep-linked messages */
+    .user-message.highlight,
+    .assistant-message.highlight {
+      animation: highlight-pulse 2s ease-out;
+    }
+
+    @keyframes highlight-pulse {
+      0% {
+        box-shadow: 0 0 0 3px var(--accent);
+      }
+      100% {
+        box-shadow: 0 0 0 0 transparent;
+      }
+    }
+
+    .assistant-message > .message-timestamp {
+      padding-left: var(--line-height);
+    }
+
+    .assistant-text {
+      padding: var(--line-height);
+      padding-bottom: 0;
+    }
+
+    .message-timestamp + .assistant-text,
+    .message-timestamp + .thinking-block {
+      padding-top: 0;
+    }
+
+    .thinking-block + .assistant-text {
+      padding-top: 0;
+    }
+
+    .thinking-text {
+      padding: var(--line-height);
+      color: var(--thinkingText);
+      font-style: italic;
+      white-space: pre-wrap;
+    }
+
+    .message-timestamp + .thinking-block .thinking-text,
+    .message-timestamp + .thinking-block .thinking-collapsed {
+      padding-top: 0;
+    }
+
+    .thinking-collapsed {
+      display: none;
+      padding: var(--line-height);
+      color: var(--thinkingText);
+      font-style: italic;
+    }
+
+    /* Tool execution */
+    .tool-execution {
+      padding: var(--line-height);
+      border-radius: 4px;
+    }
+
+    .tool-execution + .tool-execution {
+      margin-top: var(--line-height);
+    }
+
+    .assistant-text + .tool-execution {
+      margin-top: var(--line-height);
+    }
+
+    .tool-execution.pending { background: var(--toolPendingBg); }
+    .tool-execution.success { background: var(--toolSuccessBg); }
+    .tool-execution.error { background: var(--toolErrorBg); }
+
+    .tool-header, .tool-name {
+      font-weight: bold;
+    }
+
+    .tool-path {
+      color: var(--accent);
+      word-break: break-all;
+    }
+
+    .line-numbers {
+      color: var(--warning);
+    }
+
+    .line-count {
+      color: var(--dim);
+    }
+
+    .tool-command {
+      font-weight: bold;
+      white-space: pre-wrap;
+      word-wrap: break-word;
+      overflow-wrap: break-word;
+      word-break: break-word;
+    }
+
+    .tool-output {
+      margin-top: var(--line-height);
+      color: var(--toolOutput);
+      word-wrap: break-word;
+      overflow-wrap: break-word;
+      word-break: break-word;
+      font-family: inherit;
+      overflow-x: auto;
+    }
+
+    .tool-output > div,
+    .output-preview > div,
+    .output-full > div {
+      margin: 0;
+      padding: 0;
+      line-height: var(--line-height);
+    }
+
+    .tool-output > div:not(.output-preview):not(.output-full),
+    .output-preview > div:not(.expand-hint),
+    .output-full > div:not(.expand-hint) {
+      white-space: pre-wrap;
+    }
+
+    .tool-output pre {
+      margin: 0;
+      padding: 0;
+      font-family: inherit;
+      color: inherit;
+      white-space: pre-wrap;
+      word-wrap: break-word;
+      overflow-wrap: break-word;
+    }
+
+    .tool-output code {
+      padding: 0;
+      background: none;
+      color: var(--text);
+    }
+
+    .tool-output.expandable {
+      cursor: pointer;
+    }
+
+    .tool-output.expandable:hover {
+      opacity: 0.9;
+    }
+
+    .tool-output.expandable .output-full {
+      display: none;
+    }
+
+    .tool-output.expandable.expanded .output-preview {
+      display: none;
+    }
+
+    .tool-output.expandable.expanded .output-full {
+      display: block;
+    }
+
+    .ansi-line {
+      white-space: pre;
+    }
+
+    .tool-images {
+    }
+
+    .tool-image {
+      max-width: 100%;
+      max-height: 500px;
+      border-radius: 4px;
+      margin: var(--line-height) 0;
+    }
+
+    .expand-hint {
+      color: var(--toolOutput);
+    }
+
+    /* Diff */
+    .tool-diff {
+      font-size: 11px;
+      overflow-x: auto;
+      white-space: pre;
+    }
+
+    .diff-added { color: var(--toolDiffAdded); }
+    .diff-removed { color: var(--toolDiffRemoved); }
+    .diff-context { color: var(--toolDiffContext); }
+
+    /* Model change */
+    .model-change {
+      padding: 0 var(--line-height);
+      color: var(--dim);
+      font-size: 11px;
+    }
+
+    .model-name {
+      color: var(--borderAccent);
+      font-weight: bold;
+    }
+
+    /* Compaction / Branch Summary - matches customMessage colors from TUI */
+    .compaction {
+      background: var(--customMessageBg);
+      border-radius: 4px;
+      padding: var(--line-height);
+      cursor: pointer;
+    }
+
+    .compaction-label {
+      color: var(--customMessageLabel);
+      font-weight: bold;
+    }
+
+    .compaction-collapsed {
+      color: var(--customMessageText);
+    }
+
+    .compaction-content {
+      display: none;
+      color: var(--customMessageText);
+      white-space: pre-wrap;
+      margin-top: var(--line-height);
+    }
+
+    .compaction.expanded .compaction-collapsed {
+      display: none;
+    }
+
+    .compaction.expanded .compaction-content {
+      display: block;
+    }
+
+    /* System prompt */
+    .system-prompt {
+      background: var(--customMessageBg);
+      padding: var(--line-height);
+      border-radius: 4px;
+      margin-bottom: var(--line-height);
+    }
+
+    .system-prompt.expandable {
+      cursor: pointer;
+    }
+
+    .system-prompt-header {
+      font-weight: bold;
+      color: var(--customMessageLabel);
+    }
+
+    .system-prompt-preview {
+      color: var(--customMessageText);
+      white-space: pre-wrap;
+      word-wrap: break-word;
+      font-size: 11px;
+      margin-top: var(--line-height);
+    }
+
+    .system-prompt-expand-hint {
+      color: var(--muted);
+      font-style: italic;
+      margin-top: 4px;
+    }
+
+    .system-prompt-full {
+      display: none;
+      color: var(--customMessageText);
+      white-space: pre-wrap;
+      word-wrap: break-word;
+      font-size: 11px;
+      margin-top: var(--line-height);
+    }
+
+    .system-prompt.expanded .system-prompt-preview,
+    .system-prompt.expanded .system-prompt-expand-hint {
+      display: none;
+    }
+
+    .system-prompt.expanded .system-prompt-full {
+      display: block;
+    }
+
+    .system-prompt.provider-prompt {
+      border-left: 3px solid var(--warning);
+    }
+
+    .system-prompt-note {
+      font-size: 10px;
+      font-style: italic;
+      color: var(--muted);
+      margin-top: 4px;
+    }
+
+    /* Tools list */
+    .tools-list {
+      background: var(--customMessageBg);
+      padding: var(--line-height);
+      border-radius: 4px;
+      margin-bottom: var(--line-height);
+    }
+
+    .tools-header {
+      font-weight: bold;
+      color: var(--customMessageLabel);
+      margin-bottom: var(--line-height);
+    }
+
+    .tool-item {
+      font-size: 11px;
+    }
+
+    .tool-item-name {
+      font-weight: bold;
+      color: var(--text);
+    }
+
+    .tool-item-desc {
+      color: var(--dim);
+    }
+
+    .tool-params-hint {
+      color: var(--muted);
+      font-style: italic;
+    }
+
+    .tool-item:has(.tool-params-hint) {
+      cursor: pointer;
+    }
+
+    .tool-params-hint::after {
+      content: '[click to show parameters]';
+    }
+
+    .tool-item.params-expanded .tool-params-hint::after {
+      content: '[hide parameters]';
+    }
+
+    .tool-params-content {
+      display: none;
+      margin-top: 4px;
+      margin-left: 12px;
+      padding-left: 8px;
+      border-left: 1px solid var(--dim);
+    }
+
+    .tool-item.params-expanded .tool-params-content {
+      display: block;
+    }
+
+    .tool-param {
+      margin-bottom: 4px;
+      font-size: 11px;
+    }
+
+    .tool-param-name {
+      font-weight: bold;
+      color: var(--text);
+    }
+
+    .tool-param-type {
+      color: var(--dim);
+      font-style: italic;
+    }
+
+    .tool-param-required {
+      color: var(--warning, #e8a838);
+      font-size: 10px;
+    }
+
+    .tool-param-optional {
+      color: var(--dim);
+      font-size: 10px;
+    }
+
+    .tool-param-desc {
+      color: var(--dim);
+      margin-left: 8px;
+    }
+
+    /* Hook/custom messages */
+    .hook-message {
+      background: var(--customMessageBg);
+      color: var(--customMessageText);
+      padding: var(--line-height);
+      border-radius: 4px;
+    }
+
+    .hook-type {
+      color: var(--customMessageLabel);
+      font-weight: bold;
+    }
+
+    /* Skill invocation - matches compaction style (clickable, collapsed by default) */
+    .skill-invocation {
+      background: var(--customMessageBg);
+      border-radius: 4px;
+      padding: var(--line-height);
+      cursor: pointer;
+    }
+
+    .skill-invocation-label {
+      color: var(--customMessageLabel);
+      font-weight: bold;
+    }
+
+    .skill-invocation-collapsed {
+      color: var(--customMessageText);
+    }
+
+    .skill-invocation-content {
+      display: none;
+      color: var(--customMessageText);
+      margin-top: var(--line-height);
+    }
+
+    .skill-invocation.expanded .skill-invocation-collapsed {
+      display: none;
+    }
+
+    .skill-invocation.expanded .skill-invocation-content {
+      display: block;
+    }
+
+    .skill-invocation + .user-message {
+      margin-top: var(--line-height);
+    }
+
+    .skill-user-entry {
+      position: relative;
+    }
+
+    /* Branch summary */
+    .branch-summary {
+      background: var(--customMessageBg);
+      padding: var(--line-height);
+      border-radius: 4px;
+    }
+
+    .branch-summary-header {
+      font-weight: bold;
+      color: var(--borderAccent);
+    }
+
+    /* Error */
+    .error-text {
+      color: var(--error);
+      padding: 0 var(--line-height);
+    }
+    .tool-error {
+      color: var(--error);
+    }
+
+    /* Images */
+    .message-images {
+      margin-bottom: 12px;
+    }
+
+    .message-image {
+      max-width: 100%;
+      max-height: 400px;
+      border-radius: 4px;
+      margin: var(--line-height) 0;
+    }
+
+    /* Markdown content */
+    .markdown-content h1,
+    .markdown-content h2,
+    .markdown-content h3,
+    .markdown-content h4,
+    .markdown-content h5,
+    .markdown-content h6 {
+      color: var(--mdHeading);
+      margin: var(--line-height) 0 0 0;
+      font-weight: bold;
+    }
+
+    .markdown-content h1 { font-size: 1em; }
+    .markdown-content h2 { font-size: 1em; }
+    .markdown-content h3 { font-size: 1em; }
+    .markdown-content h4 { font-size: 1em; }
+    .markdown-content h5 { font-size: 1em; }
+    .markdown-content h6 { font-size: 1em; }
+    .markdown-content p { margin: 0; }
+    .markdown-content p + p { margin-top: var(--line-height); }
+
+    .markdown-content a {
+      color: var(--mdLink);
+      text-decoration: underline;
+    }
+
+    .markdown-content code {
+      background: rgba(128, 128, 128, 0.2);
+      color: var(--mdCode);
+      padding: 0 4px;
+      border-radius: 3px;
+      font-family: inherit;
+    }
+
+    .markdown-content pre {
+      background: transparent;
+      margin: var(--line-height) 0;
+      overflow-x: auto;
+    }
+
+    .markdown-content pre code {
+      display: block;
+      background: none;
+      color: var(--text);
+    }
+
+    .markdown-content blockquote {
+      border-left: 3px solid var(--mdQuoteBorder);
+      padding-left: var(--line-height);
+      margin: var(--line-height) 0;
+      color: var(--mdQuote);
+      font-style: italic;
+    }
+
+    .markdown-content ul,
+    .markdown-content ol {
+      margin: var(--line-height) 0;
+      padding-left: calc(var(--line-height) * 2);
+    }
+
+    .markdown-content li { margin: 0; }
+    .markdown-content li::marker { color: var(--mdListBullet); }
+
+    .markdown-content hr {
+      border: none;
+      border-top: 1px solid var(--mdHr);
+      margin: var(--line-height) 0;
+    }
+
+    .markdown-content table {
+      border-collapse: collapse;
+      margin: 0.5em 0;
+      width: 100%;
+    }
+
+    .markdown-content th,
+    .markdown-content td {
+      border: 1px solid var(--mdCodeBlockBorder);
+      padding: 6px 10px;
+      text-align: left;
+    }
+
+    .markdown-content th {
+      background: rgba(128, 128, 128, 0.1);
+      font-weight: bold;
+    }
+
+    .markdown-content img {
+      max-width: 100%;
+      border-radius: 4px;
+    }
+
+    /* Syntax highlighting */
+    .hljs { background: transparent; color: var(--text); }
+    .hljs-comment, .hljs-quote { color: var(--syntaxComment); }
+    .hljs-keyword, .hljs-selector-tag { color: var(--syntaxKeyword); }
+    .hljs-number, .hljs-literal { color: var(--syntaxNumber); }
+    .hljs-string, .hljs-doctag { color: var(--syntaxString); }
+    /* Function names: hljs v11 uses .hljs-title.function_ compound class */
+    .hljs-function, .hljs-title, .hljs-title.function_, .hljs-section, .hljs-name { color: var(--syntaxFunction); }
+    /* Types: hljs v11 uses .hljs-title.class_ for class names */
+    .hljs-type, .hljs-class, .hljs-title.class_, .hljs-built_in { color: var(--syntaxType); }
+    .hljs-attr, .hljs-variable, .hljs-variable.language_, .hljs-params, .hljs-property { color: var(--syntaxVariable); }
+    .hljs-meta, .hljs-meta .hljs-keyword, .hljs-meta .hljs-string { color: var(--syntaxKeyword); }
+    .hljs-operator { color: var(--syntaxOperator); }
+    .hljs-punctuation { color: var(--syntaxPunctuation); }
+    .hljs-subst { color: var(--text); }
+
+    /* Footer */
+    .footer {
+      margin-top: 48px;
+      padding: 20px;
+      text-align: center;
+      color: var(--dim);
+      font-size: 10px;
+    }
+
+    /* Mobile */
+    #hamburger {
+      display: none;
+      position: fixed;
+      top: 10px;
+      left: 10px;
+      z-index: 100;
+      padding: 3px 8px;
+      font-size: 12px;
+      font-family: inherit;
+      background: transparent;
+      color: var(--muted);
+      border: 1px solid var(--dim);
+      border-radius: 3px;
+      cursor: pointer;
+    }
+
+    #hamburger:hover {
+      color: var(--text);
+      border-color: var(--text);
+    }
+
+
+
+    #sidebar-overlay {
+      display: none;
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.5);
+      z-index: 98;
+    }
+
+    @media (max-width: 900px) {
+      #sidebar {
+        position: fixed;
+        left: 0;
+        width: min(var(--sidebar-width), 100vw);
+        min-width: min(var(--sidebar-width), 100vw);
+        max-width: min(var(--sidebar-width), 100vw);
+        top: 0;
+        bottom: 0;
+        height: 100vh;
+        z-index: 99;
+        transform: translateX(-100%);
+        transition: transform 0.3s;
+      }
+
+      #sidebar.open {
+        transform: translateX(0);
+      }
+
+      #sidebar-resizer {
+        display: none;
+      }
+
+      #sidebar-overlay.open {
+        display: block;
+      }
+
+      #hamburger {
+        display: block;
+      }
+
+      .sidebar-close {
+        display: block;
+      }
+
+      #content {
+        padding: var(--line-height) 16px;
+      }
+
+      #content > * {
+        max-width: 100%;
+      }
+    }
+
+    @media print {
+      #sidebar, #sidebar-resizer, #sidebar-toggle { display: none !important; }
+      body { background: white; color: black; }
+      #content { max-width: none; }
+    }
+
+  </style>
+</head>
+<body>
+  <button id="hamburger" title="Open sidebar"><svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor" stroke="none"><circle cx="6" cy="6" r="2.5"/><circle cx="6" cy="18" r="2.5"/><circle cx="18" cy="12" r="2.5"/><rect x="5" y="6" width="2" height="12"/><path d="M6 12h10c1 0 2 0 2-2V8"/></svg></button>
+  <div id="sidebar-overlay"></div>
+  <div id="app">
+    <aside id="sidebar">
+      <div class="sidebar-header">
+        <div class="sidebar-controls">
+          <input type="text" class="sidebar-search" id="tree-search" placeholder="Search...">
+        </div>
+        <div class="sidebar-filters">
+          <button class="filter-btn active" data-filter="default" title="Hide settings entries">Default</button>
+          <button class="filter-btn" data-filter="no-tools" title="Default minus tool results">No-tools</button>
+          <button class="filter-btn" data-filter="user-only" title="Only user messages">User</button>
+          <button class="filter-btn" data-filter="labeled-only" title="Only labeled entries">Labeled</button>
+          <button class="filter-btn" data-filter="all" title="Show everything">All</button>
+          <button class="sidebar-close" id="sidebar-close" title="Close">✕</button>
+        </div>
+      </div>
+      <div class="tree-container" id="tree-container"></div>
+      <div class="tree-status" id="tree-status"></div>
+    </aside>
+    <div id="sidebar-resizer" role="separator" aria-orientation="vertical" aria-label="Resize session tree sidebar"></div>
+    <main id="content">
+      <div id="header-container"></div>
+      <div id="messages"></div>
+    </main>
+    <div id="image-modal" class="image-modal">
+      <img id="modal-image" src="" alt="">
+    </div>
+  </div>
+
+  <script id="session-data" type="application/json">{"header":{"type":"session","version":3,"id":"019e9c4e-6a94-798d-bbe2-5c7a708dfe96","timestamp":"2026-06-06T09:40:45.332Z","cwd":"/home/brett/Repos/dotty-stackchan"},"entries":[{"type":"model_change","id":"c3fa7571","parentId":null,"timestamp":"2026-06-06T09:40:45.342Z","provider":"ollama","modelId":"qwen3.6:27b"},{"type":"thinking_level_change","id":"d11f00d4","parentId":"c3fa7571","timestamp":"2026-06-06T09:40:45.342Z","thinkingLevel":"low"},{"type":"message","id":"b6ef587d","parentId":"d11f00d4","timestamp":"2026-06-06T09:41:03.898Z","message":{"role":"user","content":[{"type":"text","text":"i want to delete the public discord, scale back the ambition for this project. i want it to be fun not a massive time sink. i can\n  delete the discord serrver if you remove all reference to it from readme and docs."}],"timestamp":1780738863897}},{"type":"message","id":"60683c96","parentId":"b6ef587d","timestamp":"2026-06-06T09:42:21.581Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The user wants to remove all references to Discord from the README and docs. Let me first find all references to Discord in the codebase.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Let me find all Discord references across the repo.\n\n"},{"type":"toolCall","id":"gaKrfg38kaU465Si88vr8qo6A3ojpsmf","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && grep -ri \"discord\" --include=\"*.md\" --include=\"*.yaml\" --include=\"*.yml\" --include=\"*.json\" --include=\"*.py\" --include=\"*.txt\" -l"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":6325,"output":125,"cacheRead":0,"cacheWrite":0,"totalTokens":6450,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780738863917,"responseId":"chatcmpl-wD0yP3ixkoinuIUctBNqNeXM5ORPf8Mb"}},{"type":"message","id":"f11acd17","parentId":"60683c96","timestamp":"2026-06-06T09:42:22.512Z","message":{"role":"toolResult","toolCallId":"gaKrfg38kaU465Si88vr8qo6A3ojpsmf","toolName":"bash","content":[{"type":"text","text":".claude/worktrees/issue-135-asr/.github/workflows/ci.yml\n.claude/worktrees/issue-135-asr/.github/workflows/firmware-release.yml\n.claude/worktrees/issue-135-asr/ROADMAP.md\n.claude/worktrees/issue-135-asr/community/discord/README.md\n.claude/worktrees/issue-135-asr/community/discord/provision.py\n.claude/worktrees/issue-135-asr/community/discord/requirements.txt\n.claude/worktrees/issue-135-asr/community/discord/welcome-and-rules.md\n.claude/worktrees/issue-135-asr/docs/vision-alignment-review-2026-05-29.md\n.claude/worktrees/issue-135-asr/tests/test_bridge_routes.py\n.claude/worktrees/issue-135-asr/README.md\n.claude/worktrees/issue-21-birdge-firware-divergence/.github/workflows/ci.yml\n.claude/worktrees/issue-21-birdge-firware-divergence/.github/workflows/firmware-release.yml\n.claude/worktrees/issue-21-birdge-firware-divergence/README.md\n.claude/worktrees/issue-21-birdge-firware-divergence/ROADMAP.md\n.claude/worktrees/issue-21-birdge-firware-divergence/community/discord/README.md\n.claude/worktrees/issue-21-birdge-firware-divergence/community/discord/provision.py\n.claude/worktrees/issue-21-birdge-firware-divergence/community/discord/requirements.txt\n.claude/worktrees/issue-21-birdge-firware-divergence/community/discord/welcome-and-rules.md\n.claude/worktrees/issue-21-birdge-firware-divergence/docs/vision-alignment-review-2026-05-29.md\n.claude/worktrees/issue-21-birdge-firware-divergence/tests/test_bridge_routes.py\ndocs/vision-alignment-review-2026-05-29.md\n.github/workflows/firmware-release.yml\n.github/workflows/ci.yml\nfirmware/firmware/xiaozhi-esp32/README.md\nfirmware/firmware/xiaozhi-esp32/README_ja.md\nfirmware/firmware/xiaozhi-esp32/README_zh.md\n.venv-singing/lib/python3.14/site-packages/music21/languageExcerpts/trainingData/fr.txt\n.venv-singing/lib/python3.14/site-packages/music21/languageExcerpts/trainingData/it.txt\n.venv-singing/lib/python3.14/site-packages/scipy/stats/_hypotests.py\n.venv-singing/lib/python3.14/site-packages/scipy/stats/_stats_py.py\ntests/test_bridge_routes.py\nnode_modules/tailwindcss/README.md\nnode_modules/daisyui/README.md\ndotty-pi-ext/node_modules/@earendil-works/pi-coding-agent/README.md\ndotty-pi-ext/node_modules/highlight.js/README.md\ndotty-pi-ext/node_modules/fast-xml-parser/README.md\ndotty-pi-ext/node_modules/zod/README.md\ndotty-pi-ext/node_modules/node-fetch/README.md\ncommunity/discord/requirements.txt\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/__main__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/abc.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/activity.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/appinfo.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/asset.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/audit_logs.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/channel.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/client.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/colour.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/components.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/embeds.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/emoji.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/enums.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/errors.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/file.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/flags.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/gateway.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/guild.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/http.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/integrations.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/interactions.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/invite.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/member.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/message.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/object.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/oggparse.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/opus.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/partial_emoji.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/permissions.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/player.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/presences.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/raw_models.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/reaction.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/role.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/scheduled_event.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/search.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/shard.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/sku.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/soundboard.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/state.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/sticker.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/subscription.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/team.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/template.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/threads.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/user.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/utils.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/voice_client.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/voice_state.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/widget.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/checks.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/commands.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/errors.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/installs.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/models.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/namespace.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/transformers.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/translator.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/app_commands/tree.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/bot.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/cog.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/context.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/converter.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/cooldowns.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/core.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/errors.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/flags.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/help.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/hybrid.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/commands/parameters.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ext/tasks/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/types/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/types/integration.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/action_row.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/button.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/checkbox.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/container.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/dynamic.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/file.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/file_upload.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/item.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/media_gallery.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/modal.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/radio.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/section.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/select.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/text_input.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/thumbnail.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/ui/view.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/webhook/__init__.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/webhook/async_.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord/webhook/sync.py\ncommunity/discord/.venv/lib/python3.14/site-packages/discord_py-2.7.1.dist-info/top_level.txt\ncommunity/discord/welcome-and-rules.md\ncommunity/discord/README.md\ncommunity/discord/provision.py\nROADMAP.md\nREADME.md\nAUDIT-REPORT.md\naudit-draft-issues.md\n"}],"isError":false,"timestamp":1780738942512}},{"type":"message","id":"59f0a58f","parentId":"f11acd17","timestamp":"2026-06-06T09:42:44.302Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Let me focus on the files that are actually in the main repo (not .claude worktrees, node_modules, .venv, or the firmware submodule). The relevant files are:\n\n1. `README.md`\n2. `ROADMAP.md`\n3. `docs/vision-alignment-review-2026-05-29.md`\n4. `.github/workflows/ci.yml`\n5. `.github/workflows/firmware-release.yml`\n6. `tests/test_bridge_routes.py`\n7. `community/discord/` (entire directory)\n8. `AUDIT-REPORT.md`\n9. `audit-draft-issues.md`\n\nLet me read each of these to understand the Discord references.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Let me check the relevant project files (excluding worktrees, venvs, node_modules, and firmware submodule):\n\n"},{"type":"toolCall","id":"HHklw75ZcoRLtHIgALKmFEpssfeYPiqO","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && grep -in \"discord\" README.md ROADMAP.md AUDIT-REPORT.md audit-draft-issues.md docs/vision-alignment-review-2026-05-29.md .github/workflows/ci.yml .github/workflows/firmware-release.yml tests/test_bridge_routes.py"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":2853,"output":282,"cacheRead":6449,"cacheWrite":0,"totalTokens":9584,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780738942512,"responseId":"chatcmpl-Ie8eMnIxczXUxAuzgUGJHY5hXgrbRU6v"}},{"type":"message","id":"540306ee","parentId":"59f0a58f","timestamp":"2026-06-06T09:42:44.307Z","message":{"role":"toolResult","toolCallId":"HHklw75ZcoRLtHIgALKmFEpssfeYPiqO","toolName":"bash","content":[{"type":"text","text":"README.md:9:> ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee. The best place to ask questions, get help, or show off a build is the [Dotty community Discord](https://discord.gg/SVnkfkH4Gh).\nROADMAP.md:23:- **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Discord, Telegram, etc.) skip it automatically\nAUDIT-REPORT.md:1019:**File:** `community/discord/provision.py:93-96, 197-202`\nAUDIT-REPORT.md:1037:**File:** `community/discord/provision.py:197-202`\nAUDIT-REPORT.md:1091:**File:** `community/discord/provision.py:204-213`\naudit-draft-issues.md:368:community/discord/provision.py:93-96,197-202\naudit-draft-issues.md:1290:community/discord/provision.py:197-202\naudit-draft-issues.md:1495:community/discord/provision.py:204-213\ndocs/vision-alignment-review-2026-05-29.md:198:#### M12. `docs/voice-mode-entry.md` attributes face-greeter to bridge.py and references a removed Discord daemon\ndocs/vision-alignment-review-2026-05-29.md:200:- **What's wrong:** \"the relay forwards that event to the bridge, where `_perception_face_greeter` (in `bridge.py`)…\" (0 occurrences in bridge.py); \"see the env block in `bridge.py` for the full set of knobs\" (knobs `FACE_GREET_TEXT`/`FACE_GREET_MIN_INTERVAL_SEC` now live in `dotty-behaviour/config.py:277-281`); \"the Discord daemon and the portal 'Greet' button\" (the Discord *daemon* was removed — `bridge/templates/discord.html` is deleted per git status; the surviving `community/discord/provision.py` is an unrelated provisioning bot).\ndocs/vision-alignment-review-2026-05-29.md:202:- **Fix (doc):** Repoint to `dotty-behaviour/consumers/face_greeter.py` + `config.py` knobs; remove the Discord-daemon reference.\n.github/workflows/ci.yml:160:      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n.github/workflows/ci.yml:170:      - name: Post Discord notification\n.github/workflows/ci.yml:171:        if: env.DISCORD_WEBHOOK_URL != ''\n.github/workflows/ci.yml:174:          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n.github/workflows/firmware-release.yml:145:      - name: Post Discord notification\n.github/workflows/firmware-release.yml:147:          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n.github/workflows/firmware-release.yml:152:          if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n.github/workflows/firmware-release.yml:153:            echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n.github/workflows/firmware-release.yml:157:          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\ntests/test_bridge_routes.py:74:    The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\ntests/test_bridge_routes.py:83:    def test_discord_partial_removed(self):\ntests/test_bridge_routes.py:84:        # The dead /ui/discord partial route was deleted in #128.\ntests/test_bridge_routes.py:85:        self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n"}],"isError":false,"timestamp":1780738964307}},{"type":"message","id":"6df647a2","parentId":"540306ee","timestamp":"2026-06-06T09:42:51.575Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Now let me look at the community/discord directory to understand what needs to be deleted:\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"zGKpkIryBwFUS0dvproaiHV9p52LhX2W","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && ls -la community/discord/ && echo \"---\" && ls -la community/"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":1095,"output":76,"cacheRead":9583,"cacheWrite":0,"totalTokens":10754,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780738964308,"responseId":"chatcmpl-u8Y43jG6E9hBLdeajVidaAIPDqsdH1Yk"}},{"type":"message","id":"ac974927","parentId":"6df647a2","timestamp":"2026-06-06T09:42:51.582Z","message":{"role":"toolResult","toolCallId":"zGKpkIryBwFUS0dvproaiHV9p52LhX2W","toolName":"bash","content":[{"type":"text","text":"total 36\ndrwxr-xr-x 1 brett brett   176 May 22 21:22 .\ndrwxr-xr-x 1 brett brett    14 May 22 16:43 ..\n-rw-r--r-- 1 brett brett   454 May 22 17:27 .env\n-rw-r--r-- 1 brett brett   382 May 22 16:43 .env.example\n-rw-r--r-- 1 brett brett    12 May 22 17:28 .gitignore\n-rw-r--r-- 1 brett brett 10813 May 22 21:22 provision.py\n-rw-r--r-- 1 brett brett  3682 May 22 20:45 README.md\n-rw-r--r-- 1 brett brett    39 May 22 16:43 requirements.txt\ndrwxr-xr-x 1 brett brett    76 May 22 17:28 .venv\n-rw-r--r-- 1 brett brett  1922 May 22 17:42 welcome-and-rules.md\n---\ntotal 0\ndrwxr-xr-x 1 brett brett   14 May 22 16:43 .\ndrwxr-xr-x 1 brett brett 1400 Jun  5 21:09 ..\ndrwxr-xr-x 1 brett brett  176 May 22 21:22 discord\n"}],"isError":false,"timestamp":1780738971582}},{"type":"message","id":"2ad56cd8","parentId":"ac974927","timestamp":"2026-06-06T09:43:15.811Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Now let me read the relevant files to understand what to edit. Let me read the README.md first to find the Discord reference context.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Let me read the relevant sections to make precise edits:\n\n"},{"type":"toolCall","id":"PGLxcXDo4gWCGVqtvUVqVf7ZeQDguuO7","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/README.md","limit":30}},{"type":"toolCall","id":"n2e4bQF434FjFTdOKe7oftcSifMKw0X0","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/ROADMAP.md","limit":30}},{"type":"toolCall","id":"jf4Gvl34VY2PVCJlDnclvctZQmZCMxV6","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/docs/vision-alignment-review-2026-05-29.md","offset":195,"limit":15}},{"type":"toolCall","id":"pqI2eUet1MvlgKO4LzfXbaCrxK6iIEzL","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml","offset":155,"limit":25}},{"type":"toolCall","id":"14Nvelle0kukEtDXk1uGpYYiqRqMCLf6","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml","offset":140,"limit":25}},{"type":"toolCall","id":"HYHXq4jalQT4eXpMsjkqYkm2sqps9bdk","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py","offset":70,"limit":20}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":415,"output":418,"cacheRead":10753,"cacheWrite":0,"totalTokens":11586,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780738971582,"responseId":"chatcmpl-M3RXYOMLELD68kOeDspz76zhltqKSmY3"}},{"type":"message","id":"bedfe94e","parentId":"2ad56cd8","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"PGLxcXDo4gWCGVqtvUVqVf7ZeQDguuO7","toolName":"read","content":[{"type":"text","text":"<p align=\"center\">\n  <img src=\"bridge/assets/dotty-hero.svg\" alt=\"Dotty mascot\" width=\"200\">\n</p>\n\n# Dotty\n\n**Your self-hosted [StackChan](https://github.com/m5stack/StackChan) robot assistant — kid-minded by default, hackable by design, private by architecture.**\n\n> ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee. The best place to ask questions, get help, or show off a build is the [Dotty community Discord](https://discord.gg/SVnkfkH4Gh).\n>\n> **Known rough edges:** face emoji rendering is missing visual differentiation for 4 of 9 emotions (sad / surprise / love / laughing); sound-direction localizer has a hardware-AEC-related left-bias on M5Stack CoreS3 (energy detection works, direction is unreliable); kid-voice ASR accuracy on SenseVoice has a kid-speech gap that whisper.cpp will close in a follow-up.\n\nDotty is a fully self-hosted voice stack for the M5Stack StackChan desktop robot. Open-source firmware on the robot, [xiaozhi-esp32-server](https://github.com/xinnan-tech/xiaozhi-esp32-server) for voice I/O, and a local **pi** coding agent as the brain. ASR, TTS, and session state all run on your own hardware. The LLM is pluggable — the shipped default runs a small fast model for plain conversation and escalates hard questions to a more capable model, with [llama-swap](./docs/cookbook/llama-swap-concurrent-models.md) as the recommended local backend. Swap in [Ollama](./docs/cookbook/run-fully-local.md) for the simpler single-binary option, or point at OpenRouter / any OpenAI-compatible API if you'd rather use the cloud.\n\nOut of the box, Dotty ships in **Kid Mode** — the persona plus a per-turn prompt sandwich keep responses age-appropriate and on-topic. This is prompt-level steering, **not** an output content filter (a blocked-words filter is planned — see [#138](https://github.com/BrettKinny/dotty-stackchan/issues/138)), and it's no substitute for supervision. Disable Kid Mode for a general-purpose assistant.\n\n## Why I built this\n\nI didn't like the idea of a camera and microphone running in my house unless I could (1) self-host the whole stack end-to-end and (2) understand the whole stack end-to-end. Off-the-shelf voice assistants fail both tests — audio leaves the house, the model is opaque, and you're trusting a vendor's privacy posture forever.\n\nSo Dotty is the version that passes: every component runs on hardware I own, every seam is documented and swappable, and the only thing that can leave the LAN is whatever LLM call I explicitly route out (and even that swaps to a local model with a config change). It's also meant to be fun — a friendly desktop robot for the kids, and an interesting hobby project to keep building on.\n\n## Features\n\n- **Kid Mode (on by default)** — age-appropriate responses via persona + per-turn prompt steering. An output content filter is planned, not yet shipped ([#138](https://github.com/BrettKinny/dotty-stackchan/issues/138)); Kid Mode is not a substitute for supervision. Toggle off for general-purpose use. See [`docs/kid-mode.md`](./docs/kid-mode.md).\n- **Local ASR** — FunASR SenseVoiceSmall runs on your hardware, no cloud transcription.\n- **Local or cloud TTS** — Piper (offline) or EdgeTTS (cloud). Swap with a config change.\n- **Streaming responses** — the bridge streams LLM output to the voice pipeline for lower perceived latency.\n- **Emoji expressions** — every response starts with an emoji that the firmware maps to a face animation (smile, laugh, sad, surprise, thinking, angry, love, sleepy, neutral).\n- **Voice tools** — the pi agent can search its memory, escalate hard questions to a bigger model, take a photo, and play songs, all mid-conversation.\n\n[82 more lines in file. Use offset=31 to continue.]"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"c32c3025","parentId":"bedfe94e","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"n2e4bQF434FjFTdOKe7oftcSifMKw0X0","toolName":"read","content":[{"type":"text","text":"# Roadmap\n\n> This is a living document. See [CONTRIBUTING.md](CONTRIBUTING.md) to get involved.\n\n## Shipping now (v0.1)\n\nv0.1 is the first tagged release — early-feedback alpha. Everything in this list runs end-to-end on the maintainer's hardware. v1.0 is gated on real-world feedback from external users; see [Known issues](#known-issues-as-of-v01) below.\n\n- **Kid Mode** -- opt-in child-safety guardrails: topic blocklist, self-harm redirect, content filter, age-appropriate vocabulary (on by default, disable with `DOTTY_KID_MODE=false`)\n- **Local ASR** -- FunASR SenseVoiceSmall, English-pinned, runs on your Docker host\n- **Local TTS** -- Piper voice synthesis, no cloud dependency\n- **Streaming LLM responses** -- NDJSON token-level streaming with first-token latency ~1.2s\n- **Emoji-driven expressions** -- LLM output prefixed with emoji; firmware maps to face animations\n- **Persona system** -- swappable persona files (`personas/*.md`), customizable via `make setup`\n- **MCP tool integration** -- 11 firmware-advertised tools (head servos, LEDs, camera, reminders, volume, brightness, screen theme)\n- **Photo-based vision** -- \"What do you see?\" triggers camera capture + vision model description\n- **Calendar context injection** -- Google Calendar events surfaced to the LLM for contextual reminders\n- **Length-aware brevity** -- default 1-2 short sentences, up to 6 for open-ended asks (story, explanation, list); cap enforced in code via `MAX_SENTENCES`\n- **ASR noise filtering** -- rejects punctuation-only / sub-threshold utterances\n- **Single-host deployment** -- all four server services (xiaozhi-server, dotty-pi, dotty-behaviour, bridge.py) run as Docker containers on one machine\n- **`make setup` wizard** -- interactive first-run: name your robot, fetch models, validate config\n- **MkDocs Material docs site** -- architecture, protocols, quickstart, troubleshooting, FAQ\n- **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Discord, Telegram, etc.) skip it automatically\n- **`/xiaozhi/admin/*` endpoints** -- live-session control surface on xiaozhi-server: `set-state`, `set-toggle`, `set-face-identified`, `set-head-angles`, `inject-text`, `abort`, `take-photo`, `play-asset`, `songs`, `say`, `devices`. See [`architecture.md`](https://brettkinny.github.io/dotty-stackchan/latest/architecture/#admin-surface-two-services-two-prefixes)\n- **Smart-mode** -- smart-mode flips ambient/behaviour only. The inner-loop **model-swap is v2 scope and not wired** on the live `PiVoiceLLM` path. (The instant in-process model-swap once provided by the now-removed `Tier1Slim` provider — added in `b73f583`, removed in the 2026-05-29 alignment pass — is gone.)\n- **llama-swap voice/coding matrix** -- `qwen3.5:4b` (voice inner loop) + `qwen3.6:27b-think` (think_hard target) co-resident under the `voice` matrix set; `qwen3.6:27b` for `pi` CLI runs alone under `coding`. See [`cookbook/llama-swap-concurrent-models.md`](https://brettkinny.github.io/dotty-stackchan/latest/cookbook/llama-swap-concurrent-models/)\n- **Perception event bus** -- firmware `face_detected` / `face_lost` / `sound_event` / `state_changed` frames relay through xiaozhi's `EventTextMessageHandler` to `dotty-behaviour`'s `/api/perception/event`, fanned out to 11 consumer classes (config-gated; includes face_greeter, sound_turner, face_lost_aborter, wake_word_turner, face_identified_refresher, purr_player)\n- **Fully-local backend support** -- `compose.local.override.yml` for Ollama (single binary, simple) plus llama-swap recipe for concurrent multi-model serving. Both shipped; choose based on whether you need multiple models resident at once\n- **Voice catalog + install helper** -- `docs/voice-catalog.md` (12 Piper + 6 EdgeTTS) + `make voice-install` -- shipped\n- **Versioned docs via `mike`** -- `/latest/`, `/v0.1/`, `/dev/` URL structure shipped\n\n[63 more lines in file. Use offset=31 to continue.]"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"192f2149","parentId":"c32c3025","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"jf4Gvl34VY2PVCJlDnclvctZQmZCMxV6","toolName":"read","content":[{"type":"text","text":"- **Why it matters:** Propagates a wrong \"live\" claim for a v2/unimplemented feature.\n- **Fix (doc):** Add the modes.md v2-scope caveat to the bullet.\n\n#### M12. `docs/voice-mode-entry.md` attributes face-greeter to bridge.py and references a removed Discord daemon\n- **Files:** `docs/voice-mode-entry.md:24, 26, 42`; `bridge.py`\n- **What's wrong:** \"the relay forwards that event to the bridge, where `_perception_face_greeter` (in `bridge.py`)…\" (0 occurrences in bridge.py); \"see the env block in `bridge.py` for the full set of knobs\" (knobs `FACE_GREET_TEXT`/`FACE_GREET_MIN_INTERVAL_SEC` now live in `dotty-behaviour/config.py:277-281`); \"the Discord daemon and the portal 'Greet' button\" (the Discord *daemon* was removed — `bridge/templates/discord.html` is deleted per git status; the surviving `community/discord/provision.py` is an unrelated provisioning bot).\n- **Why it matters:** Misdirects anyone configuring the face-greeting path to the wrong service and file.\n- **Fix (doc):** Repoint to `dotty-behaviour/consumers/face_greeter.py` + `config.py` knobs; remove the Discord-daemon reference.\n\n#### M13. `mkdocs.yml` nav omits `modes.md` (the authoritative doc) and 7 others\n- **Files:** `mkdocs.yml:39-80`; orphans: `docs/modes.md`, `docs/quickstart.md`, `docs/tier1slim.md`, `docs/wake-word.md`, `docs/proactive-greetings.md`, `docs/cutover-behaviour.md`, `docs/speaker-id-investigation.md`, `docs/cookbook/llama-swap-concurrent-models.md`\n- **What's wrong:** Eight docs are present but absent from the nav (and there's no `not_in_nav`/exclude mechanism — MkDocs Material warns per orphan). `modes.md` and `quickstart.md` are cross-linked from in-nav `docs/README.md` yet unreachable via site nav.\n- **Why it matters:** The doc the vision designates authoritative isn't in the published site.\n- **Fix (doc):** Add `modes.md`, `tier1slim.md`, `wake-word.md`, `quickstart.md`, `proactive-greetings.md`, and the llama-swap cookbook page to nav. `cutover-behaviour.md` and `speaker-id-investigation.md` may stay out as historical/investigation notes (document why).\n\n\n[79 more lines in file. Use offset=210 to continue.]"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"e823c078","parentId":"192f2149","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"pqI2eUet1MvlgKO4LzfXbaCrxK6iIEzL","toolName":"read","content":[{"type":"text","text":"    runs-on: ubuntu-latest\n    needs: [yaml-lint, compose-validate, config-parse, lint, python-tests, pi-ext-tests, frontmatter-check, docs-links]\n    if: failure()\n    env:\n      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n      REPO: ${{ github.repository }}\n      REF: ${{ github.ref_name }}\n      RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n    steps:\n      - name: Post Slack notification\n        if: env.SLACK_WEBHOOK_URL != ''\n        run: |\n          payload=$(jq -cn --arg t \":x: *CI failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n          curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n      - name: Post Discord notification\n        if: env.DISCORD_WEBHOOK_URL != ''\n        run: |\n          payload=$(jq -cn --arg c \":x: **CI failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"924d97ca","parentId":"e823c078","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"14Nvelle0kukEtDXk1uGpYYiqRqMCLf6","toolName":"read","content":[{"type":"text","text":"            echo \"SLACK_WEBHOOK_URL not set, skipping Slack notification\"\n            exit 0\n          fi\n          payload=$(jq -cn --arg t \":x: *Firmware build failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n          curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n      - name: Post Discord notification\n        env:\n          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n          REPO: ${{ github.repository }}\n          REF: ${{ github.ref_name }}\n          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n        run: |\n          if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n            echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n            exit 0\n          fi\n          payload=$(jq -cn --arg c \":x: **Firmware build failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"32325136","parentId":"924d97ca","timestamp":"2026-06-06T09:43:15.815Z","message":{"role":"toolResult","toolCallId":"HYHXq4jalQT4eXpMsjkqYkm2sqps9bdk","toolName":"read","content":[{"type":"text","text":"\nclass DashboardRenderFixTests(unittest.TestCase):\n    \"\"\"Guards the #128 'busted render' repairs against regression.\n\n    The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\n    the local `systemctl` query could never work inside the Unraid\n    container), so its partial route must now 404. The Smart Mode card was\n    relabelled to be honest about the live PiVoiceLLM path, which performs\n    no model swap (Tier1Slim — the only provider that hot-swapped — was\n    removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n    card must render and say so rather than naming a defunct model.\n    \"\"\"\n\n    def test_discord_partial_removed(self):\n        # The dead /ui/discord partial route was deleted in #128.\n        self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n\n    def test_smart_mode_partial_renders(self):\n        # Route survives and renders its card chrome even with no\n        # smart_mode_getter wired (available=False path).\n\n[308 more lines in file. Use offset=90 to continue.]"}],"isError":false,"timestamp":1780738995815}},{"type":"message","id":"c39fc35c","parentId":"32325136","timestamp":"2026-06-06T09:43:54.074Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Now I have a clear picture. Here's what needs to happen:\n\n1. **Delete `community/discord/` directory** entirely (including its `.venv`)\n2. **`README.md`** — remove the Discord link from the warning blurb\n3. **`ROADMAP.md`** — the mention of \"Discord, Telegram, etc.\" in the kid-mode channel routing bullet is just a passing example of messaging platforms. I could remove \"Discord\" specifically but keep the rest. Actually, looking at the context, this is about Kid Mode routing and Discord is just listed as an example messaging platform. Since the user is scaling back ambition, removing the reference makes sense but the rest of the bullet is still relevant to the project.\n\n\n4. For the audit and vision review documents, the references to Discord are historical records of what was already removed, so I'll leave those as-is.\n5. **`.github/workflows/ci.yml`** and **`.github/workflows/firmware-release.yml`** — remove the Discord notification steps and webhook environment variables\n6. **`tests/test_bridge_routes.py`** — the Discord test is just checking that a removed route returns 404, so I should remove that test case\n\nNow I'll start making these changes.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Here's the plan. The `AUDIT-REPORT.md`, `audit-draft-issues.md`, and `docs/vision-alignment-review-2026-05-29.md` references are historical audit records (documenting what was already wrong/removed) — I'll leave those. Here's what I'll change:\n\n1. **Delete** `community/discord/` directory entirely\n2. **README.md** — remove Discord link from warning blurb\n3. **ROADMAP.md** — remove \"Discord\" from messaging-platform example\n4. **`.github/workflows/ci.yml`** — remove Discord notification step + env var\n5. **`.github/workflows/firmware-release.yml`** — remove Discord notification step + env var\n6. **`tests/test_bridge_routes.py`** — remove the Discord 404 test (no longer meaningful)\n\n"},{"type":"toolCall","id":"S9zN6i7co3GGfM78rYY84pItKJqYV4Lu","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && rm -rf community/discord && rmdir community"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":3670,"output":505,"cacheRead":11585,"cacheWrite":0,"totalTokens":15760,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780738995815,"responseId":"chatcmpl-Fy29bbgyRnPBRrtWKOHXHsnK7YFJ63Ub"}},{"type":"message","id":"2c3e5033","parentId":"c39fc35c","timestamp":"2026-06-06T09:43:54.114Z","message":{"role":"toolResult","toolCallId":"S9zN6i7co3GGfM78rYY84pItKJqYV4Lu","toolName":"bash","content":[{"type":"text","text":"(no output)"}],"isError":false,"timestamp":1780739034114}},{"type":"message","id":"542fcb6f","parentId":"2c3e5033","timestamp":"2026-06-06T09:43:58.063Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to make the edits now. Let me do them all.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"swykxZHLx0L6C2KIjuKQzevBmra0t58W","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && ls community/"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":19,"output":58,"cacheRead":15759,"cacheWrite":0,"totalTokens":15836,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739034114,"responseId":"chatcmpl-Iwd9ddSstb5vYnekwK4Z36VnH0t2H4ay"}},{"type":"message","id":"ed9a5140","parentId":"542fcb6f","timestamp":"2026-06-06T09:43:58.067Z","message":{"role":"toolResult","toolCallId":"swykxZHLx0L6C2KIjuKQzevBmra0t58W","toolName":"bash","content":[{"type":"text","text":"ls: cannot access 'community/': No such file or directory\n\n\nCommand exited with code 2"}],"details":{},"isError":true,"timestamp":1780739038067}},{"type":"message","id":"72a01c78","parentId":"ed9a5140","timestamp":"2026-06-06T09:44:08.816Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Good, the community directory is gone. Now let me make the edits to all the files.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Good. Now the file edits:\n\n"},{"type":"toolCall","id":"DreLu5GlFiH6jFjJq0HfpUrNDL29kANh","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/README.md","edits":[{"oldText":"Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee. The best place to ask questions, get help, or show off a build is the [Dotty community Discord](https://discord.gg/SVnkfkH4Gh).","newText":"Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee."}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":36,"output":230,"cacheRead":15835,"cacheWrite":0,"totalTokens":16101,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739038067,"responseId":"chatcmpl-LiaJzMpks8nCQsLj4p6cIZxOSYDDcPrW"}},{"type":"message","id":"442d117c","parentId":"72a01c78","timestamp":"2026-06-06T09:44:08.869Z","message":{"role":"toolResult","toolCallId":"DreLu5GlFiH6jFjJq0HfpUrNDL29kANh","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/README.md."}],"details":{"diff":"     ...\n   5 # Dotty\n   6 \n   7 **Your self-hosted [StackChan](https://github.com/m5stack/StackChan) robot assistant — kid-minded by default, hackable by design, private by architecture.**\n   8 \n-  9 > ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee. The best place to ask questions, get help, or show off a build is the [Dotty community Discord](https://discord.gg/SVnkfkH4Gh).\n+  9 > ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee.\n  10 >\n  11 > **Known rough edges:** face emoji rendering is missing visual differentiation for 4 of 9 emotions (sad / surprise / love / laughing); sound-direction localizer has a hardware-AEC-related left-bias on M5Stack CoreS3 (energy detection works, direction is unreliable); kid-voice ASR accuracy on SenseVoice has a kid-speech gap that whisper.cpp will close in a follow-up.\n  12 \n  13 Dotty is a fully self-hosted voice stack for the M5Stack StackChan desktop robot. Open-source firmware on the robot, [xiaozhi-esp32-server](https://github.com/xinnan-tech/xiaozhi-esp32-server) for voice I/O, and a local **pi** coding agent as the brain. ASR, TTS, and session state all run on your own hardware. The LLM is pluggable — the shipped default runs a small fast model for plain conversation and escalates hard questions to a more capable model, with [llama-swap](./docs/cookbook/llama-swap-concurrent-models.md) as the recommended local backend. Swap in [Ollama](./docs/cookbook/run-fully-local.md) for the simpler single-binary option, or point at OpenRouter / any OpenAI-compatible API if you'd rather use the cloud.\n     ...","patch":"--- /home/brett/Repos/dotty-stackchan/README.md\n+++ /home/brett/Repos/dotty-stackchan/README.md\n@@ -5,9 +5,9 @@\n # Dotty\n \n **Your self-hosted [StackChan](https://github.com/m5stack/StackChan) robot assistant — kid-minded by default, hackable by design, private by architecture.**\n \n-> ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee. The best place to ask questions, get help, or show off a build is the [Dotty community Discord](https://discord.gg/SVnkfkH4Gh).\n+> ⚠️ **Heads up: this is not a stable project yet.** Dotty is buggy, frequently broken, and actively changing day-to-day. End-to-end behaviour works on the maintainer's hardware but regressions land all the time, the API and config surface shifts without notice, and a fresh deploy on someone else's gear has not been verified. Treat this as a hobby-grade work-in-progress, not a polished product. Bugs, PRs, and \"this didn't work for me\" issues all very welcome. 🍺☕ If you do try a fresh end-to-end deploy, please get in touch — I'll buy you a beer or a coffee.\n >\n > **Known rough edges:** face emoji rendering is missing visual differentiation for 4 of 9 emotions (sad / surprise / love / laughing); sound-direction localizer has a hardware-AEC-related left-bias on M5Stack CoreS3 (energy detection works, direction is unreliable); kid-voice ASR accuracy on SenseVoice has a kid-speech gap that whisper.cpp will close in a follow-up.\n \n Dotty is a fully self-hosted voice stack for the M5Stack StackChan desktop robot. Open-source firmware on the robot, [xiaozhi-esp32-server](https://github.com/xinnan-tech/xiaozhi-esp32-server) for voice I/O, and a local **pi** coding agent as the brain. ASR, TTS, and session state all run on your own hardware. The LLM is pluggable — the shipped default runs a small fast model for plain conversation and escalates hard questions to a more capable model, with [llama-swap](./docs/cookbook/llama-swap-concurrent-models.md) as the recommended local backend. Swap in [Ollama](./docs/cookbook/run-fully-local.md) for the simpler single-binary option, or point at OpenRouter / any OpenAI-compatible API if you'd rather use the cloud.\n","firstChangedLine":9},"isError":false,"timestamp":1780739048869}},{"type":"message","id":"28387166","parentId":"442d117c","timestamp":"2026-06-06T09:44:18.814Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to fix the edits for the remaining files. Let me do them one at a time.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"tFzZM0rrKahDohCmL8ZrWlxBvF3CU76x","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/ROADMAP.md","edits":[{"oldText":"**Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Discord, Telegram, etc.) skip it automatically","newText":"**Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Telegram, etc.) skip it automatically"}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":39,"output":208,"cacheRead":16100,"cacheWrite":0,"totalTokens":16347,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739048870,"responseId":"chatcmpl-SQMCU5RNKepMh8Ooz5P7VL48wK1w9KXy"}},{"type":"message","id":"f2aa4994","parentId":"28387166","timestamp":"2026-06-06T09:44:18.818Z","message":{"role":"toolResult","toolCallId":"tFzZM0rrKahDohCmL8ZrWlxBvF3CU76x","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/ROADMAP.md."}],"details":{"diff":"    ...\n 19 - **ASR noise filtering** -- rejects punctuation-only / sub-threshold utterances\n 20 - **Single-host deployment** -- all four server services (xiaozhi-server, dotty-pi, dotty-behaviour, bridge.py) run as Docker containers on one machine\n 21 - **`make setup` wizard** -- interactive first-run: name your robot, fetch models, validate config\n 22 - **MkDocs Material docs site** -- architecture, protocols, quickstart, troubleshooting, FAQ\n-23 - **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Discord, Telegram, etc.) skip it automatically\n+23 - **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Telegram, etc.) skip it automatically\n 24 - **`/xiaozhi/admin/*` endpoints** -- live-session control surface on xiaozhi-server: `set-state`, `set-toggle`, `set-face-identified`, `set-head-angles`, `inject-text`, `abort`, `take-photo`, `play-asset`, `songs`, `say`, `devices`. See [`architecture.md`](https://brettkinny.github.io/dotty-stackchan/latest/architecture/#admin-surface-two-services-two-prefixes)\n 25 - **Smart-mode** -- smart-mode flips ambient/behaviour only. The inner-loop **model-swap is v2 scope and not wired** on the live `PiVoiceLLM` path. (The instant in-process model-swap once provided by the now-removed `Tier1Slim` provider — added in `b73f583`, removed in the 2026-05-29 alignment pass — is gone.)\n 26 - **llama-swap voice/coding matrix** -- `qwen3.5:4b` (voice inner loop) + `qwen3.6:27b-think` (think_hard target) co-resident under the `voice` matrix set; `qwen3.6:27b` for `pi` CLI runs alone under `coding`. See [`cookbook/llama-swap-concurrent-models.md`](https://brettkinny.github.io/dotty-stackchan/latest/cookbook/llama-swap-concurrent-models/)\n 27 - **Perception event bus** -- firmware `face_detected` / `face_lost` / `sound_event` / `state_changed` frames relay through xiaozhi's `EventTextMessageHandler` to `dotty-behaviour`'s `/api/perception/event`, fanned out to 11 consumer classes (config-gated; includes face_greeter, sound_turner, face_lost_aborter, wake_word_turner, face_identified_refresher, purr_player)\n    ...","patch":"--- /home/brett/Repos/dotty-stackchan/ROADMAP.md\n+++ /home/brett/Repos/dotty-stackchan/ROADMAP.md\n@@ -19,9 +19,9 @@\n - **ASR noise filtering** -- rejects punctuation-only / sub-threshold utterances\n - **Single-host deployment** -- all four server services (xiaozhi-server, dotty-pi, dotty-behaviour, bridge.py) run as Docker containers on one machine\n - **`make setup` wizard** -- interactive first-run: name your robot, fetch models, validate config\n - **MkDocs Material docs site** -- architecture, protocols, quickstart, troubleshooting, FAQ\n-- **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Discord, Telegram, etc.) skip it automatically\n+- **Kid Mode channel routing** -- voice channels are kid-safe by default; the kid-mode sandwich (English-pin, emoji prefix, topic blocklist, jailbreak resistance) only applies when the inbound `channel` is in `VOICE_CHANNELS`, so messaging-platform channels (Telegram, etc.) skip it automatically\n - **`/xiaozhi/admin/*` endpoints** -- live-session control surface on xiaozhi-server: `set-state`, `set-toggle`, `set-face-identified`, `set-head-angles`, `inject-text`, `abort`, `take-photo`, `play-asset`, `songs`, `say`, `devices`. See [`architecture.md`](https://brettkinny.github.io/dotty-stackchan/latest/architecture/#admin-surface-two-services-two-prefixes)\n - **Smart-mode** -- smart-mode flips ambient/behaviour only. The inner-loop **model-swap is v2 scope and not wired** on the live `PiVoiceLLM` path. (The instant in-process model-swap once provided by the now-removed `Tier1Slim` provider — added in `b73f583`, removed in the 2026-05-29 alignment pass — is gone.)\n - **llama-swap voice/coding matrix** -- `qwen3.5:4b` (voice inner loop) + `qwen3.6:27b-think` (think_hard target) co-resident under the `voice` matrix set; `qwen3.6:27b` for `pi` CLI runs alone under `coding`. See [`cookbook/llama-swap-concurrent-models.md`](https://brettkinny.github.io/dotty-stackchan/latest/cookbook/llama-swap-concurrent-models/)\n - **Perception event bus** -- firmware `face_detected` / `face_lost` / `sound_event` / `state_changed` frames relay through xiaozhi's `EventTextMessageHandler` to `dotty-behaviour`'s `/api/perception/event`, fanned out to 11 consumer classes (config-gated; includes face_greeter, sound_turner, face_lost_aborter, wake_word_turner, face_identified_refresher, purr_player)\n","firstChangedLine":23},"isError":false,"timestamp":1780739058818}},{"type":"message","id":"74b73abd","parentId":"f2aa4994","timestamp":"2026-06-06T09:44:28.889Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to continue with the remaining edits. Let me do the CI workflow, firmware-release workflow, and test file.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"3BujVcWDWXV9Jjv2pJbGH6l0I3LiEDSm","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml","edits":[{"oldText":"      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n      REPO:","newText":"      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n      REPO:"}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":40,"output":156,"cacheRead":16346,"cacheWrite":0,"totalTokens":16542,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739058818,"responseId":"chatcmpl-17thbJBOyx8DxSjPKjuMmL4twEPep92f"}},{"type":"message","id":"217f508b","parentId":"74b73abd","timestamp":"2026-06-06T09:44:28.890Z","message":{"role":"toolResult","toolCallId":"3BujVcWDWXV9Jjv2pJbGH6l0I3LiEDSm","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml."}],"details":{"diff":"     ...\n 156     needs: [yaml-lint, compose-validate, config-parse, lint, python-tests, pi-ext-tests, frontmatter-check, docs-links]\n 157     if: failure()\n 158     env:\n 159       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n-160       DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n 161       REPO: ${{ github.repository }}\n 162       REF: ${{ github.ref_name }}\n 163       RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n 164     steps:\n     ...","patch":"--- /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml\n+++ /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml\n@@ -156,9 +156,8 @@\n     needs: [yaml-lint, compose-validate, config-parse, lint, python-tests, pi-ext-tests, frontmatter-check, docs-links]\n     if: failure()\n     env:\n       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n-      DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n       REPO: ${{ github.repository }}\n       REF: ${{ github.ref_name }}\n       RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n     steps:\n","firstChangedLine":160},"isError":false,"timestamp":1780739068890}},{"type":"message","id":"2a392661","parentId":"217f508b","timestamp":"2026-06-06T09:44:35.861Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to remove the Discord notification step from ci.yml and also from firmware-release.yml, and remove the test from test_bridge_routes.py. Let me read the exact context for each.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"V2bCrixk2qfWkXscGyqAkZosUUDyYOcS","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml","offset":158,"limit":20}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":43,"output":107,"cacheRead":16541,"cacheWrite":0,"totalTokens":16691,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739068891,"responseId":"chatcmpl-Akdj7gKhW9db8YLaU6T7jnPKdqEFQXNL"}},{"type":"message","id":"fb38dfe8","parentId":"2a392661","timestamp":"2026-06-06T09:44:35.862Z","message":{"role":"toolResult","toolCallId":"V2bCrixk2qfWkXscGyqAkZosUUDyYOcS","toolName":"read","content":[{"type":"text","text":"    env:\n      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n      REPO: ${{ github.repository }}\n      REF: ${{ github.ref_name }}\n      RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n    steps:\n      - name: Post Slack notification\n        if: env.SLACK_WEBHOOK_URL != ''\n        run: |\n          payload=$(jq -cn --arg t \":x: *CI failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n          curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n      - name: Post Discord notification\n        if: env.DISCORD_WEBHOOK_URL != ''\n        run: |\n          payload=$(jq -cn --arg c \":x: **CI failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n"}],"isError":false,"timestamp":1780739075862}},{"type":"message","id":"edc094fa","parentId":"fb38dfe8","timestamp":"2026-06-06T09:44:47.016Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to remove the Discord notification step from ci.yml.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"tlVStILbZ7ChrABX5jDtsbZWd3YuNvvA","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml","edits":[{"oldText":"      - name: Post Discord notification\n        if: env.DISCORD_WEBHOOK_URL != ''\n        run: |\n          payload=$(jq -cn --arg c \":x: **CI failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"","newText":""}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":278,"output":178,"cacheRead":16690,"cacheWrite":0,"totalTokens":17146,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739075862,"responseId":"chatcmpl-Wcfob1DKNupV4cGDj6PDEyyWscOW2fbi"}},{"type":"message","id":"5efca01c","parentId":"edc094fa","timestamp":"2026-06-06T09:44:47.017Z","message":{"role":"toolResult","toolCallId":"tlVStILbZ7ChrABX5jDtsbZWd3YuNvvA","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml."}],"details":{"diff":"     ...\n 165         if: env.SLACK_WEBHOOK_URL != ''\n 166         run: |\n 167           payload=$(jq -cn --arg t \":x: *CI failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n 168           curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n-169       - name: Post Discord notification\n-170         if: env.DISCORD_WEBHOOK_URL != ''\n-171         run: |\n-172           payload=$(jq -cn --arg c \":x: **CI failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n-173           curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n+169 ","patch":"--- /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml\n+++ /home/brett/Repos/dotty-stackchan/.github/workflows/ci.yml\n@@ -165,9 +165,5 @@\n         if: env.SLACK_WEBHOOK_URL != ''\n         run: |\n           payload=$(jq -cn --arg t \":x: *CI failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n           curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n-      - name: Post Discord notification\n-        if: env.DISCORD_WEBHOOK_URL != ''\n-        run: |\n-          payload=$(jq -cn --arg c \":x: **CI failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n-          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n+\n","firstChangedLine":169},"isError":false,"timestamp":1780739087017}},{"type":"message","id":"8b0e0f15","parentId":"5efca01c","timestamp":"2026-06-06T09:44:53.370Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to continue editing the remaining files: firmware-release.yml and test_bridge_routes.py.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"hBPaP2jn0Un6tpSHthrqVBNmqO6rwUHm","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml","limit":30,"offset":130}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":43,"output":90,"cacheRead":17145,"cacheWrite":0,"totalTokens":17278,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739087017,"responseId":"chatcmpl-ditRA704dWLe93BWTqCjY16mVzGORemc"}},{"type":"message","id":"9a0894c9","parentId":"8b0e0f15","timestamp":"2026-06-06T09:44:53.371Z","message":{"role":"toolResult","toolCallId":"hBPaP2jn0Un6tpSHthrqVBNmqO6rwUHm","toolName":"read","content":[{"type":"text","text":"    if: failure()\n    steps:\n      - name: Post Slack notification\n        env:\n          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}\n          REPO: ${{ github.repository }}\n          REF: ${{ github.ref_name }}\n          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n        run: |\n          if [ -z \"$SLACK_WEBHOOK_URL\" ]; then\n            echo \"SLACK_WEBHOOK_URL not set, skipping Slack notification\"\n            exit 0\n          fi\n          payload=$(jq -cn --arg t \":x: *Firmware build failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n          curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n      - name: Post Discord notification\n        env:\n          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n          REPO: ${{ github.repository }}\n          REF: ${{ github.ref_name }}\n          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n        run: |\n          if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n            echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n            exit 0\n          fi\n          payload=$(jq -cn --arg c \":x: **Firmware build failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n"}],"isError":false,"timestamp":1780739093371}},{"type":"message","id":"f47ef33a","parentId":"9a0894c9","timestamp":"2026-06-06T09:45:09.787Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Now I need to remove the Discord notification step from firmware-release.yml.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"UXCIGsOzeHWO5wzmhsbZQB0uOH3Dundj","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml","edits":[{"oldText":"      - name: Post Discord notification\n        env:\n          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n          REPO: ${{ github.repository }}\n          REF: ${{ github.ref_name }}\n          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n        run: |\n          if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n            echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n            exit 0\n          fi\n          payload=$(jq -cn --arg c \":x: **Firmware build failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"","newText":""}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":538,"output":279,"cacheRead":17145,"cacheWrite":0,"totalTokens":17962,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739093371,"responseId":"chatcmpl-Dmz75pXIixxa91TGPUASJzfXlroiyvwM"}},{"type":"message","id":"56ce9c98","parentId":"f47ef33a","timestamp":"2026-06-06T09:45:09.788Z","message":{"role":"toolResult","toolCallId":"UXCIGsOzeHWO5wzmhsbZQB0uOH3Dundj","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml."}],"details":{"diff":"     ...\n 141             exit 0\n 142           fi\n 143           payload=$(jq -cn --arg t \":x: *Firmware build failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n 144           curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n-145       - name: Post Discord notification\n-146         env:\n-147           DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n-148           REPO: ${{ github.repository }}\n-149           REF: ${{ github.ref_name }}\n-150           RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n-151         run: |\n-152           if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n-153             echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n-154             exit 0\n-155           fi\n-156           payload=$(jq -cn --arg c \":x: **Firmware build failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n-157           curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n+145 ","patch":"--- /home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml\n+++ /home/brett/Repos/dotty-stackchan/.github/workflows/firmware-release.yml\n@@ -141,17 +141,5 @@\n             exit 0\n           fi\n           payload=$(jq -cn --arg t \":x: *Firmware build failed* · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{text: $t}')\n           curl -fsS -X POST \"$SLACK_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n-      - name: Post Discord notification\n-        env:\n-          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}\n-          REPO: ${{ github.repository }}\n-          REF: ${{ github.ref_name }}\n-          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\n-        run: |\n-          if [ -z \"$DISCORD_WEBHOOK_URL\" ]; then\n-            echo \"DISCORD_WEBHOOK_URL not set, skipping Discord notification\"\n-            exit 0\n-          fi\n-          payload=$(jq -cn --arg c \":x: **Firmware build failed** · \\`${REPO}\\` · \\`${REF}\\` — ${RUN_URL}\" '{content: $c}')\n-          curl -fsS -X POST \"$DISCORD_WEBHOOK_URL\" -H 'Content-Type: application/json' -d \"$payload\"\n+\n","firstChangedLine":145},"isError":false,"timestamp":1780739109788}},{"type":"message","id":"97118638","parentId":"56ce9c98","timestamp":"2026-06-06T09:45:16.202Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I need to remove the Discord test from test_bridge_routes.py. Let me read more context first.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"8HF3U6fcxAq4P8CgrL10vFOUjgNEmW1t","name":"read","arguments":{"path":"/home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py","limit":30,"offset":70}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":326,"output":87,"cacheRead":17679,"cacheWrite":0,"totalTokens":18092,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739109788,"responseId":"chatcmpl-HDkOazh7eiSNifAxpCJWPQoP9UzBJXV6"}},{"type":"message","id":"4b9a0dcf","parentId":"97118638","timestamp":"2026-06-06T09:45:16.203Z","message":{"role":"toolResult","toolCallId":"8HF3U6fcxAq4P8CgrL10vFOUjgNEmW1t","toolName":"read","content":[{"type":"text","text":"\nclass DashboardRenderFixTests(unittest.TestCase):\n    \"\"\"Guards the #128 'busted render' repairs against regression.\n\n    The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\n    the local `systemctl` query could never work inside the Unraid\n    container), so its partial route must now 404. The Smart Mode card was\n    relabelled to be honest about the live PiVoiceLLM path, which performs\n    no model swap (Tier1Slim — the only provider that hot-swapped — was\n    removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n    card must render and say so rather than naming a defunct model.\n    \"\"\"\n\n    def test_discord_partial_removed(self):\n        # The dead /ui/discord partial route was deleted in #128.\n        self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n\n    def test_smart_mode_partial_renders(self):\n        # Route survives and renders its card chrome even with no\n        # smart_mode_getter wired (available=False path).\n        r = client.get(\"/ui/smart-mode\")\n        self.assertEqual(r.status_code, 200)\n        self.assertIn(\"Smart Mode\", r.text)\n\n    def test_smart_mode_card_is_honest_about_no_swap(self):\n        # On the live PiVoiceLLM path there is no model swap, so the card\n        # must describe the pending-v2 state, not name a defunct model.\n        body = client.get(\"/ui/smart-mode\").text\n        self.assertIn(\"model-swap pending\", body)\n\n\n[298 more lines in file. Use offset=100 to continue.]"}],"isError":false,"timestamp":1780739116203}},{"type":"message","id":"551b634d","parentId":"4b9a0dcf","timestamp":"2026-06-06T09:45:43.098Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Now I need to remove the test_discord_partial_removed method and update the docstring to remove the Discord reference.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"MVqNaa9N50OWKZkRXx2xYtjoxzO7a3M4","name":"edit","arguments":{"path":"/home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py","edits":[{"oldText":"class DashboardRenderFixTests(unittest.TestCase):\n    \"\"\"Guards the #128 'busted render' repairs against regression.\n\n    The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\n    the local `systemctl` query could never work inside the Unraid\n    container), so its partial route must now 404. The Smart Mode card was\n    relabelled to be honest about the live PiVoiceLLM path, which performs\n    no model swap (Tier1Slim — the only provider that hot-swapped — was\n    removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n    card must render and say so rather than naming a defunct model.\n    \"\"\"\n\n    def test_discord_partial_removed(self):\n        # The dead /ui/discord partial route was deleted in #128.\n        self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n\n    def test_smart_mode_partial_renders(self):","newText":"class DashboardRenderFixTests(unittest.TestCase):\n    \"\"\"Guards the #128 'busted render' repairs against regression.\n\n    The Smart Mode card was\n    relabelled to be honest about the live PiVoiceLLM path, which performs\n    no model swap (Tier1Slim — the only provider that hot-swapped — was\n    removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n    card must render and say so rather than naming a defunct model.\n    \"\"\"\n\n    def test_smart_mode_partial_renders(self):"}]}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":404,"output":465,"cacheRead":18091,"cacheWrite":0,"totalTokens":18960,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739116203,"responseId":"chatcmpl-XQvZ5G7YgWSzWuZHPra2wK7XIwYSwWdn"}},{"type":"message","id":"83b9849d","parentId":"551b634d","timestamp":"2026-06-06T09:45:43.100Z","message":{"role":"toolResult","toolCallId":"MVqNaa9N50OWKZkRXx2xYtjoxzO7a3M4","toolName":"edit","content":[{"type":"text","text":"Successfully replaced 1 block(s) in /home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py."}],"details":{"diff":"     ...\n  70 \n  71 class DashboardRenderFixTests(unittest.TestCase):\n  72     \"\"\"Guards the #128 'busted render' repairs against regression.\n  73 \n- 74     The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\n- 75     the local `systemctl` query could never work inside the Unraid\n- 76     container), so its partial route must now 404. The Smart Mode card was\n+ 74     The Smart Mode card was\n  77     relabelled to be honest about the live PiVoiceLLM path, which performs\n  78     no model swap (Tier1Slim — the only provider that hot-swapped — was\n  79     removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n  80     card must render and say so rather than naming a defunct model.\n  81     \"\"\"\n  82 \n- 83     def test_discord_partial_removed(self):\n- 84         # The dead /ui/discord partial route was deleted in #128.\n- 85         self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n- 86 \n  87     def test_smart_mode_partial_renders(self):\n  88         # Route survives and renders its card chrome even with no\n  89         # smart_mode_getter wired (available=False path).\n  90         r = client.get(\"/ui/smart-mode\")\n     ...","patch":"--- /home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py\n+++ /home/brett/Repos/dotty-stackchan/tests/test_bridge_routes.py\n@@ -70,21 +70,15 @@\n \n class DashboardRenderFixTests(unittest.TestCase):\n     \"\"\"Guards the #128 'busted render' repairs against regression.\n \n-    The zeroclaw-discord daemon card was removed (ZeroClaw retired in #36;\n-    the local `systemctl` query could never work inside the Unraid\n-    container), so its partial route must now 404. The Smart Mode card was\n+    The Smart Mode card was\n     relabelled to be honest about the live PiVoiceLLM path, which performs\n     no model swap (Tier1Slim — the only provider that hot-swapped — was\n     removed in the 2026-05-29 alignment pass; the swap is v2 scope). The\n     card must render and say so rather than naming a defunct model.\n     \"\"\"\n \n-    def test_discord_partial_removed(self):\n-        # The dead /ui/discord partial route was deleted in #128.\n-        self.assertEqual(client.get(\"/ui/discord\").status_code, 404)\n-\n     def test_smart_mode_partial_renders(self):\n         # Route survives and renders its card chrome even with no\n         # smart_mode_getter wired (available=False path).\n         r = client.get(\"/ui/smart-mode\")\n","firstChangedLine":74},"isError":false,"timestamp":1780739143100}},{"type":"message","id":"a72eb4f4","parentId":"83b9849d","timestamp":"2026-06-06T09:45:53.192Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"I've made all the necessary edits. Let me verify by doing a final grep to make sure I haven't missed any Discord references in the main repo files (excluding worktrees, venvs, node_modules, and firmware submodule).\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Let me verify no Discord references remain in the main repo files:\n\n"},{"type":"toolCall","id":"4EOH6Tnk9XsaBUkkPEsvNGH04wt8vzZH","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && grep -ri \"discord\" --include=\"*.md\" --include=\"*.yaml\" --include=\"*.yml\" --include=\"*.json\" --include=\"*.py\" --include=\"*.txt\" -l --exclude-dir=.claude --exclude-dir=.venv --exclude-dir=.venv-singing --exclude-dir=node_modules --exclude-dir=community --exclude-dir=firmware"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":41,"output":183,"cacheRead":18959,"cacheWrite":0,"totalTokens":19183,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739143100,"responseId":"chatcmpl-sf63esGkg6xAiRrwnvJnogezn1Oj1K79"}},{"type":"message","id":"b574d6e2","parentId":"a72eb4f4","timestamp":"2026-06-06T09:45:53.202Z","message":{"role":"toolResult","toolCallId":"4EOH6Tnk9XsaBUkkPEsvNGH04wt8vzZH","toolName":"bash","content":[{"type":"text","text":"docs/vision-alignment-review-2026-05-29.md\nAUDIT-REPORT.md\naudit-draft-issues.md\n"}],"isError":false,"timestamp":1780739153202}},{"type":"message","id":"4525f8f5","parentId":"b574d6e2","timestamp":"2026-06-06T09:46:11.745Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The remaining references are all in historical audit/documentation files that record what was already wrong or removed. These don't need to be changed since they're just documenting history.\n\nLet me do a final check to confirm the community directory is gone.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Done. Remaining Discord mentions are only in historical audit files (`AUDIT-REPORT.md`, `audit-draft-issues.md`, `docs/vision-alignment-review-2026-05-29.md`) — those just record what was already broken/removed and don't need changing.\n\n**Summary of changes:**\n- **Deleted** `community/discord/` directory (provisioning bot, .venv, env files, README, welcome-and-rules)\n- **`README.md`** — removed \"The best place to ask questions...Dotty community Discord\" link\n- **`ROADMAP.md`** — removed \"Discord\" from messaging-platform example (kept Telegram, etc.)\n- **`.github/workflows/ci.yml`** — removed `DISCORD_WEBHOOK_URL` env var + notification step\n- **`.github/workflows/firmware-release.yml`** — removed `DISCORD_WEBHOOK_URL` env var + notification step\n- **`tests/test_bridge_routes.py`** — removed `test_discord_partial_removed` test + updated docstring"}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":47,"output":279,"cacheRead":19182,"cacheWrite":0,"totalTokens":19508,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1780739153202,"responseId":"chatcmpl-az4UMRcwyp4qXcLeow4rXogFqDl5GKn7"}},{"type":"message","id":"83d2f32b","parentId":"4525f8f5","timestamp":"2026-06-06T09:46:40.027Z","message":{"role":"user","content":[{"type":"text","text":"can you move these changes to a new branch and open a PR?"}],"timestamp":1780739200026}},{"type":"message","id":"a0c2cacd","parentId":"83d2f32b","timestamp":"2026-06-06T09:47:05.040Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The user wants me to create a new branch with the changes and open a PR. Let me figure out the repo setup first.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"EzujfkhgnFth0dpQ0z1jnmoAuURoaqN3","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git status --short && echo \"---\" && git remote -v"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":12334,"output":80,"cacheRead":6321,"cacheWrite":0,"totalTokens":18735,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739200027,"responseId":"chatcmpl-kwxySSM1r06de2MGTYS1tS1LLLtMUkrk"}},{"type":"message","id":"87d9abfb","parentId":"a0c2cacd","timestamp":"2026-06-06T09:47:05.051Z","message":{"role":"toolResult","toolCallId":"EzujfkhgnFth0dpQ0z1jnmoAuURoaqN3","toolName":"bash","content":[{"type":"text","text":" M .github/workflows/ci.yml\n M .github/workflows/firmware-release.yml\n M README.md\n M ROADMAP.md\n D community/discord/.env.example\n D community/discord/.gitignore\n D community/discord/README.md\n D community/discord/provision.py\n D community/discord/requirements.txt\n D community/discord/welcome-and-rules.md\n M tests/test_bridge_routes.py\n?? AUDIT-REPORT.md\n?? audit-draft-issues.md\n---\nfork\thttps://github.com/pboushy/dotty-stackchan.git (fetch)\nfork\thttps://github.com/pboushy/dotty-stackchan.git (push)\norigin\thttps://github.com/BrettKinny/dotty-stackchan.git (fetch)\norigin\thttps://github.com/BrettKinny/dotty-stackchan.git (push)\n"}],"isError":false,"timestamp":1780739225051}},{"type":"message","id":"5b175b02","parentId":"87d9abfb","timestamp":"2026-06-06T09:47:18.131Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The working tree has changes but they're not staged or committed yet. Let me also note there are `.env` and `.gitignore` files in `community/discord/` that were untracked (the `.env` is likely local secrets, and the `.gitignore`/`.venv` were already gitignored). The `git status --short` shows tracked files being deleted — that's correct.\n\nThe `?? AUDIT-REPORT.md` and `?? audit-draft-issues.md` are untracked files unrelated to our changes.\n\nThe remote is `origin` (BrettKinny/dotty-stackchan). Let me create a branch, commit the changes, push, and open a PR.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"SD8MtX2png4xNTNhL5SbqLzPKjt22Afl","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git checkout -b remove-discord"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":193,"output":194,"cacheRead":18734,"cacheWrite":0,"totalTokens":19121,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739225052,"responseId":"chatcmpl-lodOL5TnOFkjPB1oJkoSdL2dD74BDESY"}},{"type":"message","id":"4992fd5b","parentId":"5b175b02","timestamp":"2026-06-06T09:47:18.136Z","message":{"role":"toolResult","toolCallId":"SD8MtX2png4xNTNhL5SbqLzPKjt22Afl","toolName":"bash","content":[{"type":"text","text":"Switched to a new branch 'remove-discord'\n"}],"isError":false,"timestamp":1780739238136}},{"type":"message","id":"e32908da","parentId":"4992fd5b","timestamp":"2026-06-06T09:47:37.535Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Wait, the `.env` file is shown as deleted in `git status --short` but it wasn't in the earlier `ls -la` output. Let me check — actually `ls -la` showed it was there. The `- D` prefix in git status means it's a tracked file that has been deleted. That's fine since we deleted the whole `community/discord/` directory.\n\nBut wait — I only deleted the directory with `rm -rf community/discord && rmdir community`. The `.env` file was in there. Since `rmdir community` succeeded, the directory was empty after removing `discord/`, meaning `community/` only contained `discord/`. That all checks out.\n\nLet me stage and commit, then push and create the PR.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"Ld8QHco52BTrY5FuURg8SvY4pJRjPSMS","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git add -A && git commit -m \"remove community Discord server\n\n- Delete community/discord/ directory (provisioning bot, config, docs)\n- Remove Discord link from README.md warning blurb\n- Remove Discord mention from ROADMAP.md messaging-platform example\n- Remove Discord webhook notification steps from CI and firmware-release workflows\n- Remove test_discord_partial_removed from bridge routes tests\n\nScale back public-facing ambition — keeping this fun, not a time sink.\""}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":27,"output":298,"cacheRead":19120,"cacheWrite":0,"totalTokens":19445,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739238136,"responseId":"chatcmpl-Gc5aHQ9sIt3ml8yQLntMQM8dOijgjbgo"}},{"type":"message","id":"0fc6cdf5","parentId":"e32908da","timestamp":"2026-06-06T09:47:37.551Z","message":{"role":"toolResult","toolCallId":"Ld8QHco52BTrY5FuURg8SvY4pJRjPSMS","toolName":"bash","content":[{"type":"text","text":"[remove-discord 20c6646] remove community Discord server\n 13 files changed, 4539 insertions(+), 447 deletions(-)\n create mode 100644 AUDIT-REPORT.md\n create mode 100644 audit-draft-issues.md\n delete mode 100644 community/discord/.env.example\n delete mode 100644 community/discord/.gitignore\n delete mode 100644 community/discord/README.md\n delete mode 100644 community/discord/provision.py\n delete mode 100644 community/discord/requirements.txt\n delete mode 100644 community/discord/welcome-and-rules.md\n"}],"isError":false,"timestamp":1780739257551}},{"type":"message","id":"bb27e9b0","parentId":"0fc6cdf5","timestamp":"2026-06-06T09:47:49.074Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Wait — `AUDIT-REPORT.md` and `audit-draft-issues.md` were untracked files that got picked up by `git add -A`. Those aren't part of the Discord removal. Let me unstage them and amend the commit.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"Those two untracked files snuck in. Let me clean that up.\n\n"},{"type":"toolCall","id":"tpleSshkhRRiKniDGWfNdWHYhGbRZRBD","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git reset HEAD AUDIT-REPORT.md audit-draft-issues.md && git reset HEAD community/discord/.env && git commit --amend -m \"remove community Discord server\n\n- Delete community/discord/ directory (provisioning bot, config, docs)\n- Remove Discord link from README.md warning blurb\n- Remove Discord mention from ROADMAP.md messaging-platform example\n- Remove Discord webhook notification steps from CI and firmware-release workflows\n- Remove test_discord_partial_removed from bridge routes tests\n\nScale back public-facing ambition — keeping this fun, not a time sink.\""}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":186,"output":227,"cacheRead":19444,"cacheWrite":0,"totalTokens":19857,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739257551,"responseId":"chatcmpl-QCsqiTNQRJC18bMtCgkmOmC2AaC58jmV"}},{"type":"message","id":"bf1c109c","parentId":"bb27e9b0","timestamp":"2026-06-06T09:47:49.087Z","message":{"role":"toolResult","toolCallId":"tpleSshkhRRiKniDGWfNdWHYhGbRZRBD","toolName":"bash","content":[{"type":"text","text":"[remove-discord e38d9b7] remove community Discord server\n Date: Sat Jun 6 19:47:37 2026 +1000\n 13 files changed, 4539 insertions(+), 447 deletions(-)\n create mode 100644 AUDIT-REPORT.md\n create mode 100644 audit-draft-issues.md\n delete mode 100644 community/discord/.env.example\n delete mode 100644 community/discord/.gitignore\n delete mode 100644 community/discord/README.md\n delete mode 100644 community/discord/provision.py\n delete mode 100644 community/discord/requirements.txt\n delete mode 100644 community/discord/welcome-and-rules.md\n"}],"isError":false,"timestamp":1780739269087}},{"type":"message","id":"f39512c4","parentId":"bf1c109c","timestamp":"2026-06-06T09:48:04.191Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Hmm, it still shows those files in the commit. Let me check the git status and the actual commit to see what's going on.\n\nWait, the `git reset HEAD` unstage command should work, but the commit message still shows them. Let me check if the files are still in the staging area or if the amend didn't actually change things because the files were already in the index from the original `git add -A`. Let me do `git reset HEAD` without the file argument to unstage everything, then selectively re-stage.\n\nActually no, `git reset HEAD AUDIT-REPORT.md audit-draft-issues.md` should have unstaged them. But the commit summary still shows them. Let me check `git show --stat` to see what's actually in the commit.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"xgvBGLrY1ImCEGSoxakHVbGCPiZTnnHR","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git show --stat HEAD | head -30"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":441,"output":214,"cacheRead":19626,"cacheWrite":0,"totalTokens":20281,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739269087,"responseId":"chatcmpl-uiKJ3ks2MKfXK99tgZYtTDLxMgfFZHNA"}},{"type":"message","id":"0ce4a34c","parentId":"f39512c4","timestamp":"2026-06-06T09:48:04.199Z","message":{"role":"toolResult","toolCallId":"xgvBGLrY1ImCEGSoxakHVbGCPiZTnnHR","toolName":"bash","content":[{"type":"text","text":"commit e38d9b75f13347c8adf15bec9406576f2cca24e5\nAuthor: Brett Kinny <brett@squarewavesystems.com.au>\nDate:   Sat Jun 6 19:47:37 2026 +1000\n\n    remove community Discord server\n    \n    - Delete community/discord/ directory (provisioning bot, config, docs)\n    - Remove Discord link from README.md warning blurb\n    - Remove Discord mention from ROADMAP.md messaging-platform example\n    - Remove Discord webhook notification steps from CI and firmware-release workflows\n    - Remove test_discord_partial_removed from bridge routes tests\n    \n    Scale back public-facing ambition — keeping this fun, not a time sink.\n\n .github/workflows/ci.yml               |    7 +-\n .github/workflows/firmware-release.yml |   14 +-\n AUDIT-REPORT.md                        | 1286 +++++++++++++\n README.md                              |    2 +-\n ROADMAP.md                             |    2 +-\n audit-draft-issues.md                  | 3248 ++++++++++++++++++++++++++++++++\n community/discord/.env.example         |    9 -\n community/discord/.gitignore           |    2 -\n community/discord/README.md            |   95 -\n community/discord/provision.py         |  274 ---\n community/discord/requirements.txt     |    2 -\n community/discord/welcome-and-rules.md |   37 -\n tests/test_bridge_routes.py            |    8 +-\n 13 files changed, 4539 insertions(+), 447 deletions(-)\n"}],"isError":false,"timestamp":1780739284199}},{"type":"message","id":"d308d8d0","parentId":"0ce4a34c","timestamp":"2026-06-06T09:48:11.898Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The audit files are still in the commit. The `git reset HEAD` didn't work because the amend already happened. Let me do a hard reset to undo the commit, then properly stage only the right files.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"mw5U0bKmeqfbv0l0sFIM95d8Wy28NEeH","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git reset --soft HEAD~1 && git reset HEAD && git status --short"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":390,"output":100,"cacheRead":20280,"cacheWrite":0,"totalTokens":20770,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739284199,"responseId":"chatcmpl-Hrlpdq7a6CP6ZnoF1Zy391MjBSXi3565"}},{"type":"message","id":"8649cea3","parentId":"d308d8d0","timestamp":"2026-06-06T09:48:11.913Z","message":{"role":"toolResult","toolCallId":"mw5U0bKmeqfbv0l0sFIM95d8Wy28NEeH","toolName":"bash","content":[{"type":"text","text":"Unstaged changes after reset:\nM\t.github/workflows/ci.yml\nM\t.github/workflows/firmware-release.yml\nM\tREADME.md\nM\tROADMAP.md\nD\tcommunity/discord/.env.example\nD\tcommunity/discord/.gitignore\nD\tcommunity/discord/README.md\nD\tcommunity/discord/provision.py\nD\tcommunity/discord/requirements.txt\nD\tcommunity/discord/welcome-and-rules.md\nM\ttests/test_bridge_routes.py\n M .github/workflows/ci.yml\n M .github/workflows/firmware-release.yml\n M README.md\n M ROADMAP.md\n D community/discord/.env.example\n D community/discord/.gitignore\n D community/discord/README.md\n D community/discord/provision.py\n D community/discord/requirements.txt\n D community/discord/welcome-and-rules.md\n M tests/test_bridge_routes.py\n?? AUDIT-REPORT.md\n?? audit-draft-issues.md\n"}],"isError":false,"timestamp":1780739291913}},{"type":"message","id":"a46f0fcd","parentId":"8649cea3","timestamp":"2026-06-06T09:48:18.729Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Good, now the audit files are untracked again. Let me stage only the Discord-related changes.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"dw3e37VSlE8Ja6eLjlpw5l7GVoW0KgK7","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git add .github/workflows/ci.yml .github/workflows/firmware-release.yml README.md ROADMAP.md tests/test_bridge_routes.py community/ && git status --short"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":216,"output":95,"cacheRead":20769,"cacheWrite":0,"totalTokens":21080,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739291913,"responseId":"chatcmpl-YdiVrsvrQlXPG8jDEmREFlwt911eJYTU"}},{"type":"message","id":"8b82213f","parentId":"a46f0fcd","timestamp":"2026-06-06T09:48:18.741Z","message":{"role":"toolResult","toolCallId":"dw3e37VSlE8Ja6eLjlpw5l7GVoW0KgK7","toolName":"bash","content":[{"type":"text","text":"M  .github/workflows/ci.yml\nM  .github/workflows/firmware-release.yml\nM  README.md\nM  ROADMAP.md\nD  community/discord/.env.example\nD  community/discord/.gitignore\nD  community/discord/README.md\nD  community/discord/provision.py\nD  community/discord/requirements.txt\nD  community/discord/welcome-and-rules.md\nM  tests/test_bridge_routes.py\n?? AUDIT-REPORT.md\n?? audit-draft-issues.md\n"}],"isError":false,"timestamp":1780739298741}},{"type":"message","id":"634985d6","parentId":"8b82213f","timestamp":"2026-06-06T09:48:25.018Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Good, only the relevant files are staged. The two untracked audit files won't be committed.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"f7yOeeMosJPmL4X8lfAH04BRvOyvqxkB","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git commit -m \"remove community Discord server\n\n- Delete community/discord/ directory (provisioning bot, config, docs)\n- Remove Discord link from README.md warning blurb\n- Remove Discord mention from ROADMAP.md messaging-platform example\n- Remove Discord webhook notification steps from CI and firmware-release workflows\n- Remove test_discord_partial_removed from bridge routes tests\n\nScale back public-facing ambition — keeping this fun, not a time sink.\""}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":126,"output":152,"cacheRead":21079,"cacheWrite":0,"totalTokens":21357,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739298741,"responseId":"chatcmpl-nuwqhaPgCCVnb1b60jeLbpIbESeVOoYg"}},{"type":"message","id":"b8252600","parentId":"634985d6","timestamp":"2026-06-06T09:48:25.026Z","message":{"role":"toolResult","toolCallId":"f7yOeeMosJPmL4X8lfAH04BRvOyvqxkB","toolName":"bash","content":[{"type":"text","text":"[remove-discord b1ddb36] remove community Discord server\n 11 files changed, 5 insertions(+), 447 deletions(-)\n delete mode 100644 community/discord/.env.example\n delete mode 100644 community/discord/.gitignore\n delete mode 100644 community/discord/README.md\n delete mode 100644 community/discord/provision.py\n delete mode 100644 community/discord/requirements.txt\n delete mode 100644 community/discord/welcome-and-rules.md\n"}],"isError":false,"timestamp":1780739305026}},{"type":"message","id":"36087ccc","parentId":"b8252600","timestamp":"2026-06-06T09:48:30.369Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Good, now only the 11 relevant files. Let me push the branch and create a PR.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"6zq8l4XfDxEnAqhl7mx0dJ7bol77iZHp","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && git push -u origin remove-discord"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":304,"output":70,"cacheRead":21201,"cacheWrite":0,"totalTokens":21575,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739305027,"responseId":"chatcmpl-6MFSL2cUENJjpH9Ci37ohSPNiqy9tFsr"}},{"type":"message","id":"206881d2","parentId":"36087ccc","timestamp":"2026-06-06T09:48:31.816Z","message":{"role":"toolResult","toolCallId":"6zq8l4XfDxEnAqhl7mx0dJ7bol77iZHp","toolName":"bash","content":[{"type":"text","text":"remote: \nremote: Create a pull request for 'remove-discord' on GitHub by visiting:        \nremote:      https://github.com/BrettKinny/dotty-stackchan/pull/new/remove-discord        \nremote: \nTo https://github.com/BrettKinny/dotty-stackchan.git\n * [new branch]      remove-discord -> remove-discord\nbranch 'remove-discord' set up to track 'origin/remove-discord'.\n"}],"isError":false,"timestamp":1780739311816}},{"type":"message","id":"a4b444d9","parentId":"206881d2","timestamp":"2026-06-06T09:48:42.379Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Let me try creating the PR via the GitHub CLI if it's installed.\n","thinkingSignature":"reasoning_content"},{"type":"toolCall","id":"iy3A22o1nmfSObLgdK9nm6ZMEcCrIwYS","name":"bash","arguments":{"command":"cd /home/brett/Repos/dotty-stackchan && gh pr create --base main --head remove-discord --title \"Remove community Discord server\" --body \"Scale back public-facing ambition — keeping this fun, not a time sink.\n\n**Changes:**\n- Delete \\`community/discord/\\` directory (provisioning bot, config, docs)\n- Remove Discord link from README.md warning blurb\n- Remove Discord mention from ROADMAP.md messaging-platform example\n- Remove Discord webhook notification steps from CI and firmware-release workflows\n- Remove \\`test_discord_partial_removed\\` from bridge routes tests\" 2>&1"}}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":107,"output":173,"cacheRead":21574,"cacheWrite":0,"totalTokens":21854,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1780739311816,"responseId":"chatcmpl-viRUdojexw6SLZj7sfbFbcxAEAZ0zkyJ"}},{"type":"message","id":"aa129309","parentId":"a4b444d9","timestamp":"2026-06-06T09:48:44.181Z","message":{"role":"toolResult","toolCallId":"iy3A22o1nmfSObLgdK9nm6ZMEcCrIwYS","toolName":"bash","content":[{"type":"text","text":"https://github.com/BrettKinny/dotty-stackchan/pull/154\n"}],"isError":false,"timestamp":1780739324181}},{"type":"message","id":"fa309520","parentId":"aa129309","timestamp":"2026-06-06T09:48:47.329Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"PR created.\n","thinkingSignature":"reasoning_content"},{"type":"text","text":"PR open: **https://github.com/BrettKinny/dotty-stackchan/pull/154**\n\nBranch: `remove-discord` → `main`"}],"api":"openai-completions","provider":"ollama","model":"qwen3.6:27b","usage":{"input":34,"output":42,"cacheRead":21853,"cacheWrite":0,"totalTokens":21929,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"stop","timestamp":1780739324181,"responseId":"chatcmpl-h328BUAXsY438f2L0MzJ15c3l3Y9Nke8"}}],"leafId":"fa309520","systemPrompt":"You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.\n\nAvailable tools:\n- read: Read file contents\n- bash: Execute bash commands (ls, grep, find, etc.)\n- edit: Make precise file edits with exact text replacement, including multiple disjoint edits in one call\n- write: Create or overwrite files\n\nIn addition to the tools above, you may have access to other custom tools depending on the project.\n\nGuidelines:\n- Use bash for file operations like ls, rg, find\n- Use read to examine files instead of cat or sed.\n- Use edit for precise changes (edits[].oldText must match exactly)\n- When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls\n- Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.\n- Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions.\n- Use write only for new files or complete rewrites.\n- Be concise in your responses\n- Show file paths clearly when working with files\n\nPi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):\n- Main documentation: /home/brett/.npm/_npx/99fca8174466655b/node_modules/@earendil-works/pi-coding-agent/README.md\n- Additional docs: /home/brett/.npm/_npx/99fca8174466655b/node_modules/@earendil-works/pi-coding-agent/docs\n- Examples: /home/brett/.npm/_npx/99fca8174466655b/node_modules/@earendil-works/pi-coding-agent/examples (extensions, custom tools, SDK)\n- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory\n- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)\n- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing\n- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)\n\n<project_context>\n\nProject-specific instructions and guidelines:\n\n<project_instructions path=\"/home/brett/Repos/dotty-stackchan/CLAUDE.md\">\n# Dotty\n\n## What This Is\n\nYour self-hosted StackChan robot assistant. A fully self-hosted voice stack for the M5Stack **StackChan** desktop robot. The default persona is \"Dotty\" (customizable via `make setup`). Voice I/O routes through a self-hosted xiaozhi-esp32-server; the brain is a **pi** coding agent running in the `dotty-pi` container. No cloud AI services — fully self-hosted except for the LLM call (replaceable with local Ollama).\n\n## Architecture\n\nThe voice path runs through a single LLM provider — `PiVoiceLLM`, selected via `selected_module.LLM` in `data/.config.yaml`. One alternate provider ships as a fallback (`OpenAICompat`). (The former `Tier1Slim` two-tier provider was removed in the 2026-05-29 alignment pass — its tool escalation depended on the retired ZeroClaw bridge.)\n\n```\n                 StackChan hardware → configured persona\n                   │  ESP32-S3, xiaozhi firmware (built from m5stack/StackChan source)\n                   │  WiFi / WebSocket (Xiaozhi protocol)\n                   ▼\n                 xiaozhi-esp32-server (Docker)\n                   ├─ ASR: FunASR SenseVoiceSmall / WhisperLocal (local)\n                   ├─ TTS: LocalPiper; EdgeTTS / StreamingEdgeTTS alternates\n                   └─ LLM: PiVoiceLLM\n                        │  PiClient → `docker exec -i dotty-pi pi --mode rpc …`  (JSONL over stdio)\n                        ▼\n                 dotty-pi container — the pi coding agent (the brain)\n                   ├─ outer loop: qwen3.5:4b on llama-swap\n                   └─ dotty-pi-ext extension → 7 voice tools:\n                        memory_lookup · remember · recall_person · remember_person · think_hard (→ qwen3.6:27b-think) · take_photo · play_song\n                   only TTS-bound text streams back to xiaozhi-server\n\n  Perception + ambient behaviour:  firmware `event` frames → xiaozhi relay → dotty-behaviour (FastAPI, :8090)\n  Admin dashboard:                 bridge.py (FastAPI, :8081, served at /ui)\n```\n\nAll four server-side services — xiaozhi-server, `dotty-pi`, `dotty-behaviour`, and the `bridge.py` dashboard — run as Docker containers on a single Docker host.\n\nSmart-mode currently flips behaviour but **not** the backend model — the model-swap path was dropped in the #36 cutover and is v2 scope (see `docs/cutover-behaviour.md`).\n\n> **Cutover note:** until the #36 cutover (executed 2026-05-19) the brain was **ZeroClaw**, a Rust AI-agent fronted by a FastAPI bridge on a separate Raspberry Pi. That path — ZeroClaw, the ACP protocol, the `ZeroClawLLM` provider, and the RPi host — has been retired. `bridge.py` survived as the dashboard service; its voice and perception roles moved to `dotty-pi` and `dotty-behaviour`. Historical record: `docs/cutover-behaviour.md`.\n\nSee `README.md` for the full visual architecture and message-flow diagrams.\n\n## Network\n\n- **Admin workstation** (this machine): Development/admin workstation. Runs Claude Code sessions.\n- **Docker host**: runs xiaozhi-esp32-server, `dotty-pi`, `dotty-behaviour`, and the `bridge.py` dashboard — all as containers. Any Linux box with Docker works. Reachable on the LAN (and optionally Tailscale).\n- **StackChan**: On LAN WiFi only (not on Tailnet). Needs LAN IPs for OTA and WebSocket.\n\nSSH access is via Tailscale hostnames. Discover actual Tailscale hostnames at runtime with `tailscale status`.\n\nThis repo uses placeholders (`<XIAOZHI_HOST>`, `<XIAOZHI_USER>`, `<XIAOZHI_PATH>`, etc.) everywhere real values would normally appear — see the \"Configuring for your environment\" section of `README.md` for the full list.\n\n## Key Paths\n\n- **xiaozhi-server install dir** (on the Docker host): `<XIAOZHI_PATH>` (e.g. `/opt/xiaozhi-server/`)\n- **Custom LLM provider** (on the Docker host): mounted into the xiaozhi container at `/opt/xiaozhi-server/core/providers/llm/pi_voice/`\n- **dotty-pi / dotty-behaviour / bridge.py**: each deployed as its own container on the Docker host (see their respective `README.md` files; deploy via `scripts/deploy-behaviour.sh` and `scripts/deploy-bridge-unraid.sh`)\n- **This project dir**: wherever you cloned `dotty-stackchan`\n\n## Ports\n\n| Service | Host | Port | Protocol |\n|---------|------|------|----------|\n| xiaozhi WebSocket | Docker host LAN IP | 8000 | ws:// |\n| xiaozhi OTA/HTTP | Docker host LAN IP | 8003 | http:// |\n| dashboard service (`bridge.py`) | Docker host LAN IP | 8081 | http:// (`/ui`) |\n| dotty-behaviour (perception, vision, greeter) | Docker host LAN IP | 8090 | http:// |\n\n## Config Files to Know\n\n- `.config.yaml` (repo root; deployed to the Docker host as `data/.config.yaml`) — the xiaozhi-server override config. Never overwrite wholesale on upgrades; merge keys.\n- `custom-providers/pi_voice/` — the **`PiVoiceLLM` provider** + `PiClient`, the default voice path. xiaozhi-server's LLM call is translated into a pi RPC request and run inside the `dotty-pi` container via `docker exec -i dotty-pi pi --mode rpc …`; pi owns the agent loop and tools, and only TTS-bound text streams back. Selected when `selected_module.LLM = PiVoiceLLM`. Requires the host docker socket bind-mounted into the xiaozhi container — see `custom-providers/pi_voice/README.md`.\n- `custom-providers/edge_stream/edge_stream.py` — custom streaming TTS provider. Mounted similarly.\n- `custom-providers/openai_compat/openai_compat.py` — OpenAI-compatible LLM provider; the alternate voice backend to `PiVoiceLLM` (point it at a local llama-swap endpoint or any OpenAI-compatible API). Selected when `selected_module.LLM = OpenAICompat`.\n- `custom-providers/piper_local/piper_local.py` — local Piper TTS provider (offline alternative to EdgeTTS).\n- `custom-providers/asr/fun_local.py` — patched FunASR provider. Adds a `language` config key (upstream hardcodes `\"auto\"`, which mis-detects Korean/Japanese on unclear English). Mounted as a file-level override over the upstream provider.\n- `custom-providers/xiaozhi-patches/{http_server,websocket_server,portal_bridge}.py` — drop-in overrides against upstream xiaozhi-server. Add the `/xiaozhi/admin/*` admin routes (inject-text, abort, set-state, set-toggle, set-head-angles, take-photo, play-asset, songs catalogue, say) and the `active_connections` registry that lets admin routes reach a live device WS. (The `set-tier1slim-model` route and `shared_llm` singleton were removed with Tier1Slim in the 2026-05-29 alignment pass.)\n- `bridge.py` — the **admin dashboard** service (FastAPI, port 8081, served at `/ui`); runs as a container on the Docker host (build via `bridge/Dockerfile`, deploy via `scripts/deploy-bridge-unraid.sh`). Its former voice and perception-bus roles were retired in #36; the dashboard now pulls its perception/vision/audio cards from `dotty-behaviour` (#115 series). Supporting modules live under `bridge/`.\n- `dotty-pi/` — Docker image + compose for the pi agent container (the brain). See `dotty-pi/README.md`.\n- `dotty-pi-ext/` — pi extension providing the **seven** voice tools (`memory_lookup`, `remember`, `recall_person`, `remember_person`, `think_hard`, `take_photo`, `play_song`), loaded into the `dotty-pi` agent. (`recall_person`/`remember_person` were added in #53.)\n- `dotty-behaviour/` — FastAPI service (port 8090): the perception event bus, ambient consumers, vision/audio explain endpoints, the proactive greeter, and calendar context. Successor to the bridge's perception role. See `dotty-behaviour/README.md`.\n- `personas/default.md` — default robot persona prompt (swappable).\n- `session-prompt.md` — Claude Code session prompt for infrastructure setup.\n\n## Emotion/Expression Protocol\n\nThe LLM response MUST start with an emoji. The xiaozhi firmware parses it into a face animation:\n😊=smile 😆=laugh 😢=sad 😮=surprise 🤔=thinking 😠=angry 😐=neutral 😍=love 😴=sleepy\n\nTwo layers enforce this on the live `PiVoiceLLM` path:\n1. **The pi agent's persona prompt** (the configured persona) — primary source.\n2. **xiaozhi-server top-level `prompt:`** in `data/.config.yaml` — injected as a system message.\n\nThe old third layer — a `_ensure_emoji_prefix` fallback in `bridge.py` — only ran on the retired ZeroClaw voice path; `PiVoiceLLM` has no equivalent, so the persona prompts are load-bearing.\n\n## Key Directories\n\n- `custom-providers/` — all custom ASR/LLM/TTS providers (mounted into the xiaozhi container)\n- `bridge/` — supporting modules for the `bridge.py` dashboard service (dashboard UI, templates, static assets, CSRF, metrics)\n- `dotty-pi/`, `dotty-pi-ext/`, `dotty-behaviour/` — the pi agent container, its voice-tool extension, and the perception/greeter service (see Config Files above)\n- `firmware/` — StackChan firmware patches, remote config, and server-side OTA assets\n- `personas/` — swappable robot persona prompts\n- `docs/` — deep technical reference (architecture, hardware, protocols, brain, latent capabilities)\n\n## Make Targets\n\nRun `make help` for the full list. Key targets:\n\n- `make setup` — interactive first-run wizard (substitutes placeholders, fetches models, starts containers)\n- `make doctor` — health checks on config, models, and services\n- `make fetch-models` — download SenseVoiceSmall + Piper voice models\n- `make up` / `make down` / `make logs` / `make status` — docker compose shortcuts\n\n## Common Maintenance Tasks\n\n- **Change TTS voice**: Edit `data/.config.yaml` on the Docker host. For the default `LocalPiper`, swap the `voice` + `model_path` + `config_path` keys (download a new `.onnx` / `.onnx.json` pair into `models/piper/`). For `EdgeTTS` / `StreamingEdgeTTS` alternates, change `TTS.EdgeTTS.voice` / `TTS.StreamingEdgeTTS.voice` and switch `selected_module.TTS`. Restart container.\n- **Change system prompt**: Edit `data/.config.yaml` on the Docker host, top-level `prompt:` block. Restart container.\n- **Check logs**: `ssh <XIAOZHI_USER>@<XIAOZHI_HOST> 'docker logs -f xiaozhi-esp32-server'`\n- **Restart pipeline**: `ssh <XIAOZHI_USER>@<XIAOZHI_HOST> 'cd <XIAOZHI_PATH> && docker compose restart'`\n- **Test the dashboard service**: `curl http://<XIAOZHI_HOST>:8081/health`\n- **Test dotty-behaviour**: `curl http://<XIAOZHI_HOST>:8090/health`\n\n## Firmware iteration\n\nThe `firmware/` directory at the root of this repo is a **git submodule** that pins a release of the StackChan firmware fork (`BrettKinny/StackChan` @ `dotty`). It exists so the public repo has a reproducible firmware-version pointer; updating it is a *release* action, not a development action. The build commands below operate inside that submodule and are appropriate for users who only have this repo cloned.\n\nIf you maintain a separate firmware checkout for active development (recommended for non-trivial firmware work — keeps the submodule clean and avoids accidental commits into a release pin), point the same `docker run` invocations at that checkout instead and bump the submodule pointer here only when cutting a release.\n\nBuild + flash the StackChan firmware locally with the cached IDF container — no GHA round-trip needed for dev cycles.\n\n```bash\ncd firmware/firmware\n\n# Build (≈5 min cold, faster incremental). fetch_repos.py clones\n# upstream xiaozhi-esp32 v2.2.4 and applies patches/xiaozhi-esp32.patch.\ndocker run --rm -v \"$PWD:/project\" -w /project \\\n  espressif/idf:v5.5.4 bash -lc \\\n  'git config --global --add safe.directory \"*\" && python fetch_repos.py && idf.py build'\n\n# USB-C flash (device shows up as /dev/ttyACM0).\ndocker run --rm -v \"$PWD:/project\" -w /project \\\n  --device=/dev/ttyACM0 espressif/idf:v5.5.4 \\\n  bash -lc 'idf.py -p /dev/ttyACM0 -b 921600 flash'\n```\n\nGotchas hit in real sessions:\n\n- **CMake GLOB cache**: when adding a new `.cpp/.h` under `main/stackchan/`, `idf.py build` will *silently* not compile it and you'll get a linker error like `undefined reference to '...'`. Force a reconfigure with `touch main/CMakeLists.txt` then rebuild — or run `idf.py reconfigure` once.\n- **`%lld` printf**: ESP-IDF newlib's printf doesn't reliably honour `%lld` in this build. Use `%.0f` with a `double` cast for >32-bit integers, or manually split the value.\n- **Upstream xiaozhi-esp32 changes** go through `firmware/firmware/patches/xiaozhi-esp32.patch`, not directly into the working tree (which `fetch_repos.py` re-fetches). After editing the upstream tree locally for a build, regenerate with `git -C firmware/firmware/xiaozhi-esp32 diff HEAD > firmware/firmware/patches/xiaozhi-esp32.patch`. Verify the patch applies cleanly to a fresh `v2.2.4` checkout before committing.\n- **`/dev/ttyACM0` disappears** after a hard reset / power cycle; if `docker run` complains \"no such file\", either re-plug the USB-C cable or wait for the device to finish booting back into the JTAG-Serial endpoint.\n\n## Ambient perception layer (Phase 1)\n\nForward-looking modes (face-detected greeting, sound-direction head-turn, future curiosity / boredom mode) all subscribe to a single perception event bus in `dotty-behaviour`. Producers are firmware-resident and emit JSON `event` frames over the WS:\n\n```json\n{\"type\":\"event\",\"name\":\"face_detected\",\"data\":{}}\n{\"type\":\"event\",\"name\":\"face_lost\",\"data\":{}}\n{\"type\":\"event\",\"name\":\"sound_event\",\"data\":{\"direction\":\"left\",\"balance\":0.997,\"energy\":1807933247}}\n```\n\nPlumbing:\n\n- **Firmware emit**: `Application::SendEvent(name, data_json)` in upstream `application.cc` (lazy-opens the WS via `OpenAudioChannel()` because xiaozhi WS is otherwise session-scoped — without lazy-open, perception events from idle silently drop).\n- **xiaozhi-server relay**: custom override at `custom-providers/xiaozhi-patches/textMessageHandlerRegistry.py` adds an `EventTextMessageHandler` that POSTs each event frame to `dotty-behaviour`'s `/api/perception/event`.\n- **dotty-behaviour bus**: the perception event bus + per-device state live in `dotty-behaviour` (`perception/state.py`, `perception/snapshot.py`).\n- **Consumers** (`dotty-behaviour/consumers/`): `face_greeter` (Hi! greeting via `/xiaozhi/admin/inject-text`), `sound_turner` (head-turn via `/xiaozhi/admin/set-head-angles`), `face_lost_aborter` (TTS abort when audience walks away), and six more — see `dotty-behaviour/README.md`.\n\nWS lifecycle is the structural fact most easily forgotten: **xiaozhi only opens the WS during a conversation**, not persistently. Anything that needs to fire a server-bound event from idle has to either (a) trigger `OpenAudioChannel()` first or (b) accept that events are session-only. Producer A and B both assume (a) — done in `SendEvent`.\n\nThe Phase 4 firmware **StateManager** (`firmware/main/stackchan/modes/state_manager.{h,cpp}`) is a producer too — it emits `state_changed` on every mutex-state transition (`idle / talk / story_time / security / sleep / dance`) so `dotty-behaviour` consumers can gate behaviour on state. `dotty-behaviour` tracks per-device `current_state` from those events.\n\n## States, toggles & LEDs\n\n`docs/modes.md` is the **authoritative source** for the six-state mutex (`idle / talk / story_time / security / sleep / dance`), the orthogonal toggles (`kid_mode`, `smart_mode`), the LED contract (state arc on left ring 0-5; face-state / kid / smart / listening indicators on right ring 6 / 8 / 9 / 11 with reserved pixels at 7 / 10 — all six right-ring pixels owned by StateManager and re-asserted at 5 Hz), the voice-phrase triggers, and the per-state backing-architecture (which states use the pi agent vs direct OpenRouter). When adding behaviour that responds to or changes Dotty's mode, read modes.md first — don't reinvent.\n\n## Deeper reference\n\nFor hardware specs, protocol details, model internals, latent capabilities, and the behavioural mode + LED contract, see [`docs/README.md`](./docs/README.md) and its linked files (`architecture.md`, `hardware.md`, `voice-pipeline.md`, `brain.md`, `protocols.md`, `modes.md`, `latent-capabilities.md`, `references.md`).\n\n## Tech Stack Refs\n\n- xiaozhi-esp32-server: https://github.com/xinnan-tech/xiaozhi-esp32-server\n- xiaozhi-esp32 firmware (upstream): https://github.com/78/xiaozhi-esp32\n- StackChan (hardware + firmware patches): https://github.com/m5stack/StackChan\n- Emotion protocol: https://xiaozhi.dev/en/docs/development/emotion/\n\n</project_instructions>\n\n</project_context>\n\n\nThe following skills provide specialized instructions for specific tasks.\nUse the read tool to load a skill's file when the task matches its description.\nWhen a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.\n\n<available_skills>\n  <skill>\n    <name>omarchy</name>\n    <description>REQUIRED for end-user customization of Linux desktop, window manager, or system config. Use when editing ~/.config/hypr/, ~/.config/waybar/, ~/.config/walker/, ~/.config/alacritty/, ~/.config/foot/, ~/.config/kitty/, ~/.config/ghostty/, ~/.config/mako/, or ~/.config/omarchy/. Triggers: Hyprland, window rules, animations, keybindings, monitors, gaps, borders, blur, opacity, waybar, walker, terminal config, themes, wallpaper, night light, idle, lock screen, screenshots, reminders, layer rules, workspace settings, display config, and user-facing omarchy commands. Excludes Omarchy source development in ~/.local/share/omarchy/ and `omarchy dev` workflows.\n</description>\n    <location>/home/brett/.pi/agent/skills/omarchy/SKILL.md</location>\n  </skill>\n</available_skills>\nCurrent date: 2026-06-06\nCurrent working directory: /home/brett/Repos/dotty-stackchan","tools":[{"name":"read","description":"Read the contents of a file. Supports text files and images (jpg, png, gif, webp). Images are sent as attachments. For text files, output is truncated to 2000 lines or 50KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.","parameters":{"type":"object","required":["path"],"properties":{"path":{"type":"string","description":"Path to the file to read (relative or absolute)"},"offset":{"type":"number","description":"Line number to start reading from (1-indexed)"},"limit":{"type":"number","description":"Maximum number of lines to read"}}}},{"name":"bash","description":"Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last 2000 lines or 50KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.","parameters":{"type":"object","required":["command"],"properties":{"command":{"type":"string","description":"Bash command to execute"},"timeout":{"type":"number","description":"Timeout in seconds (optional, no default timeout)"}}}},{"name":"edit","description":"Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.","parameters":{"type":"object","required":["path","edits"],"properties":{"path":{"type":"string","description":"Path to the file to edit (relative or absolute)"},"edits":{"type":"array","items":{"type":"object","required":["oldText","newText"],"properties":{"oldText":{"type":"string","description":"Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call."},"newText":{"type":"string","description":"Replacement text for this targeted edit."}},"additionalProperties":false},"description":"One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead."}},"additionalProperties":false}},{"name":"write","description":"Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.","parameters":{"type":"object","required":["path","content"],"properties":{"path":{"type":"string","description":"Path to the file to write (relative or absolute)"},"content":{"type":"string","description":"Content to write to the file"}}}}]}</script>
+
+  <!-- Vendored libraries -->
+  <script>/**
+ * marked v15.0.4 - a markdown parser
+ * Copyright (c) 2011-2024, Christopher Jeffrey. (MIT Licensed)
+ * https://github.com/markedjs/marked
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).marked={})}(this,(function(e){"use strict";function t(){return{async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null}}function n(t){e.defaults=t}e.defaults={async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null};const s={exec:()=>null};function r(e,t=""){let n="string"==typeof e?e:e.source;const s={replace:(e,t)=>{let r="string"==typeof t?t:t.source;return r=r.replace(i.caret,"$1"),n=n.replace(e,r),s},getRegex:()=>new RegExp(n,t)};return s}const i={codeRemoveIndent:/^(?: {1,4}| {0,3}\t)/gm,outputLinkReplace:/\\([\[\]])/g,indentCodeCompensation:/^(\s+)(?:```)/,beginningSpace:/^\s+/,endingHash:/#$/,startingSpaceChar:/^ /,endingSpaceChar:/ $/,nonSpaceChar:/[^ ]/,newLineCharGlobal:/\n/g,tabCharGlobal:/\t/g,multipleSpaceGlobal:/\s+/g,blankLine:/^[ \t]*$/,doubleBlankLine:/\n[ \t]*\n[ \t]*$/,blockquoteStart:/^ {0,3}>/,blockquoteSetextReplace:/\n {0,3}((?:=+|-+) *)(?=\n|$)/g,blockquoteSetextReplace2:/^ {0,3}>[ \t]?/gm,listReplaceTabs:/^\t+/,listReplaceNesting:/^ {1,4}(?=( {4})*[^ ])/g,listIsTask:/^\[[ xX]\] /,listReplaceTask:/^\[[ xX]\] +/,anyLine:/\n.*\n/,hrefBrackets:/^<(.*)>$/,tableDelimiter:/[:|]/,tableAlignChars:/^\||\| *$/g,tableRowBlankLine:/\n[ \t]*$/,tableAlignRight:/^ *-+: *$/,tableAlignCenter:/^ *:-+: *$/,tableAlignLeft:/^ *:-+ *$/,startATag:/^<a /i,endATag:/^<\/a>/i,startPreScriptTag:/^<(pre|code|kbd|script)(\s|>)/i,endPreScriptTag:/^<\/(pre|code|kbd|script)(\s|>)/i,startAngleBracket:/^</,endAngleBracket:/>$/,pedanticHrefTitle:/^([^'"]*[^\s])\s+(['"])(.*)\2/,unicodeAlphaNumeric:/[\p{L}\p{N}]/u,escapeTest:/[&<>"']/,escapeReplace:/[&<>"']/g,escapeTestNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/,escapeReplaceNoEncode:/[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g,unescapeTest:/&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/gi,caret:/(^|[^\[])\^/g,percentDecode:/%25/g,findPipe:/\|/g,splitPipe:/ \|/,slashPipe:/\\\|/g,carriageReturn:/\r\n|\r/g,spaceLine:/^ +$/gm,notSpaceStart:/^\S*/,endingNewline:/\n$/,listItemRegex:e=>new RegExp(`^( {0,3}${e})((?:[\t ][^\\n]*)?(?:\\n|$))`),nextBulletRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ \t][^\\n]*)?(?:\\n|$))`),hrRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`),fencesBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}(?:\`\`\`|~~~)`),headingBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}#`),htmlBeginRegex:e=>new RegExp(`^ {0,${Math.min(3,e-1)}}<(?:[a-z].*>|!--)`,"i")},l=/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,o=/(?:[*+-]|\d{1,9}[.)])/,a=r(/^(?!bull |blockCode|fences|blockquote|heading|html)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html))+?)\n {0,3}(=+|-+) *(?:\n+|$)/).replace(/bull/g,o).replace(/blockCode/g,/(?: {4}| {0,3}\t)/).replace(/fences/g,/ {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g,/ {0,3}>/).replace(/heading/g,/ {0,3}#{1,6}/).replace(/html/g,/ {0,3}<[^\n>]+>\n/).getRegex(),c=/^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/,h=/(?!\s*\])(?:\\.|[^\[\]\\])+/,p=r(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label",h).replace("title",/(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(),u=r(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g,o).getRegex(),g="address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul",k=/<!--(?:-?>|[\s\S]*?(?:-->|$))/,f=r("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|<![A-Z][\\s\\S]*?(?:>\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][\\w-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$))","i").replace("comment",k).replace("tag",g).replace("attribute",/ +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(),d=r(c).replace("hr",l).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("|table","").replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag",g).getRegex(),x={blockquote:r(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph",d).getRegex(),code:/^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/,def:p,fences:/^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/,heading:/^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,hr:l,html:f,lheading:a,list:u,newline:/^(?:[ \t]*(?:\n|$))+/,paragraph:d,table:s,text:/^[^\n]+/},b=r("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr",l).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("blockquote"," {0,3}>").replace("code","(?: {4}| {0,3}\t)[^\\n]").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag",g).getRegex(),w={...x,table:b,paragraph:r(c).replace("hr",l).replace("heading"," {0,3}#{1,6}(?:\\s|$)").replace("|lheading","").replace("table",b).replace("blockquote"," {0,3}>").replace("fences"," {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list"," {0,3}(?:[*+-]|1[.)]) ").replace("html","</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag",g).getRegex()},m={...x,html:r("^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:\"[^\"]*\"|'[^']*'|\\s[^'\"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))").replace("comment",k).replace(/tag/g,"(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(),def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/,heading:/^(#{1,6})(.*)(?:\n+|$)/,fences:s,lheading:/^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/,paragraph:r(c).replace("hr",l).replace("heading"," *#{1,6} *[^\n]").replace("lheading",a).replace("|table","").replace("blockquote"," {0,3}>").replace("|fences","").replace("|list","").replace("|html","").replace("|tag","").getRegex()},y=/^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/,$=/^( {2,}|\\)\n(?!\s*$)/,R=/[\p{P}\p{S}]/u,S=/[\s\p{P}\p{S}]/u,T=/[^\s\p{P}\p{S}]/u,z=r(/^((?![*_])punctSpace)/,"u").replace(/punctSpace/g,S).getRegex(),A=r(/^(?:\*+(?:((?!\*)punct)|[^\s*]))|^_+(?:((?!_)punct)|([^\s_]))/,"u").replace(/punct/g,R).getRegex(),_=r("^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)","gu").replace(/notPunctSpace/g,T).replace(/punctSpace/g,S).replace(/punct/g,R).getRegex(),P=r("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)","gu").replace(/notPunctSpace/g,T).replace(/punctSpace/g,S).replace(/punct/g,R).getRegex(),I=r(/\\(punct)/,"gu").replace(/punct/g,R).getRegex(),L=r(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme",/[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email",/[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex(),B=r(k).replace("(?:--\x3e|$)","--\x3e").getRegex(),C=r("^comment|^</[a-zA-Z][\\w:-]*\\s*>|^<[a-zA-Z][\\w-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment",B).replace("attribute",/\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex(),E=/(?:\[(?:\\.|[^\[\]\\])*\]|\\.|`[^`]*`|[^\[\]\\`])*?/,q=r(/^!?\[(label)\]\(\s*(href)(?:\s+(title))?\s*\)/).replace("label",E).replace("href",/<(?:\\.|[^\n<>\\])+>|[^\s\x00-\x1f]*/).replace("title",/"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex(),Z=r(/^!?\[(label)\]\[(ref)\]/).replace("label",E).replace("ref",h).getRegex(),v=r(/^!?\[(ref)\](?:\[\])?/).replace("ref",h).getRegex(),D={_backpedal:s,anyPunctuation:I,autolink:L,blockSkip:/\[[^[\]]*?\]\((?:\\.|[^\\\(\)]|\((?:\\.|[^\\\(\)])*\))*\)|`[^`]*?`|<[^<>]*?>/g,br:$,code:/^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,del:s,emStrongLDelim:A,emStrongRDelimAst:_,emStrongRDelimUnd:P,escape:y,link:q,nolink:v,punctuation:z,reflink:Z,reflinkSearch:r("reflink|nolink(?!\\()","g").replace("reflink",Z).replace("nolink",v).getRegex(),tag:C,text:/^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/,url:s},M={...D,link:r(/^!?\[(label)\]\((.*?)\)/).replace("label",E).getRegex(),reflink:r(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label",E).getRegex()},O={...D,escape:r(y).replace("])","~|])").getRegex(),url:r(/^((?:ftp|https?):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/,"i").replace("email",/[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![-_])/).getRegex(),_backpedal:/(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/,del:/^(~~?)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/,text:/^([`~]+|[^`~])(?:(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|https?:\/\/|ftp:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)))/},Q={...O,br:r($).replace("{2,}","*").getRegex(),text:r(O.text).replace("\\b_","\\b_| {2,}\\n").replace(/\{2,\}/g,"*").getRegex()},j={normal:x,gfm:w,pedantic:m},N={normal:D,gfm:O,breaks:Q,pedantic:M},G={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},H=e=>G[e];function X(e,t){if(t){if(i.escapeTest.test(e))return e.replace(i.escapeReplace,H)}else if(i.escapeTestNoEncode.test(e))return e.replace(i.escapeReplaceNoEncode,H);return e}function F(e){try{e=encodeURI(e).replace(i.percentDecode,"%")}catch{return null}return e}function U(e,t){const n=e.replace(i.findPipe,((e,t,n)=>{let s=!1,r=t;for(;--r>=0&&"\\"===n[r];)s=!s;return s?"|":" |"})).split(i.splitPipe);let s=0;if(n[0].trim()||n.shift(),n.length>0&&!n.at(-1)?.trim()&&n.pop(),t)if(n.length>t)n.splice(t);else for(;n.length<t;)n.push("");for(;s<n.length;s++)n[s]=n[s].trim().replace(i.slashPipe,"|");return n}function J(e,t,n){const s=e.length;if(0===s)return"";let r=0;for(;r<s;){const i=e.charAt(s-r-1);if(i!==t||n){if(i===t||!n)break;r++}else r++}return e.slice(0,s-r)}function K(e,t,n,s,r){const i=t.href,l=t.title||null,o=e[1].replace(r.other.outputLinkReplace,"$1");if("!"!==e[0].charAt(0)){s.state.inLink=!0;const e={type:"link",raw:n,href:i,title:l,text:o,tokens:s.inlineTokens(o)};return s.state.inLink=!1,e}return{type:"image",raw:n,href:i,title:l,text:o}}class V{options;rules;lexer;constructor(t){this.options=t||e.defaults}space(e){const t=this.rules.block.newline.exec(e);if(t&&t[0].length>0)return{type:"space",raw:t[0]}}code(e){const t=this.rules.block.code.exec(e);if(t){const e=t[0].replace(this.rules.other.codeRemoveIndent,"");return{type:"code",raw:t[0],codeBlockStyle:"indented",text:this.options.pedantic?e:J(e,"\n")}}}fences(e){const t=this.rules.block.fences.exec(e);if(t){const e=t[0],n=function(e,t,n){const s=e.match(n.other.indentCodeCompensation);if(null===s)return t;const r=s[1];return t.split("\n").map((e=>{const t=e.match(n.other.beginningSpace);if(null===t)return e;const[s]=t;return s.length>=r.length?e.slice(r.length):e})).join("\n")}(e,t[3]||"",this.rules);return{type:"code",raw:e,lang:t[2]?t[2].trim().replace(this.rules.inline.anyPunctuation,"$1"):t[2],text:n}}}heading(e){const t=this.rules.block.heading.exec(e);if(t){let e=t[2].trim();if(this.rules.other.endingHash.test(e)){const t=J(e,"#");this.options.pedantic?e=t.trim():t&&!this.rules.other.endingSpaceChar.test(t)||(e=t.trim())}return{type:"heading",raw:t[0],depth:t[1].length,text:e,tokens:this.lexer.inline(e)}}}hr(e){const t=this.rules.block.hr.exec(e);if(t)return{type:"hr",raw:J(t[0],"\n")}}blockquote(e){const t=this.rules.block.blockquote.exec(e);if(t){let e=J(t[0],"\n").split("\n"),n="",s="";const r=[];for(;e.length>0;){let t=!1;const i=[];let l;for(l=0;l<e.length;l++)if(this.rules.other.blockquoteStart.test(e[l]))i.push(e[l]),t=!0;else{if(t)break;i.push(e[l])}e=e.slice(l);const o=i.join("\n"),a=o.replace(this.rules.other.blockquoteSetextReplace,"\n    $1").replace(this.rules.other.blockquoteSetextReplace2,"");n=n?`${n}\n${o}`:o,s=s?`${s}\n${a}`:a;const c=this.lexer.state.top;if(this.lexer.state.top=!0,this.lexer.blockTokens(a,r,!0),this.lexer.state.top=c,0===e.length)break;const h=r.at(-1);if("code"===h?.type)break;if("blockquote"===h?.type){const t=h,i=t.raw+"\n"+e.join("\n"),l=this.blockquote(i);r[r.length-1]=l,n=n.substring(0,n.length-t.raw.length)+l.raw,s=s.substring(0,s.length-t.text.length)+l.text;break}if("list"!==h?.type);else{const t=h,i=t.raw+"\n"+e.join("\n"),l=this.list(i);r[r.length-1]=l,n=n.substring(0,n.length-h.raw.length)+l.raw,s=s.substring(0,s.length-t.raw.length)+l.raw,e=i.substring(r.at(-1).raw.length).split("\n")}}return{type:"blockquote",raw:n,tokens:r,text:s}}}list(e){let t=this.rules.block.list.exec(e);if(t){let n=t[1].trim();const s=n.length>1,r={type:"list",raw:"",ordered:s,start:s?+n.slice(0,-1):"",loose:!1,items:[]};n=s?`\\d{1,9}\\${n.slice(-1)}`:`\\${n}`,this.options.pedantic&&(n=s?n:"[*+-]");const i=this.rules.other.listItemRegex(n);let l=!1;for(;e;){let n=!1,s="",o="";if(!(t=i.exec(e)))break;if(this.rules.block.hr.test(e))break;s=t[0],e=e.substring(s.length);let a=t[2].split("\n",1)[0].replace(this.rules.other.listReplaceTabs,(e=>" ".repeat(3*e.length))),c=e.split("\n",1)[0],h=!a.trim(),p=0;if(this.options.pedantic?(p=2,o=a.trimStart()):h?p=t[1].length+1:(p=t[2].search(this.rules.other.nonSpaceChar),p=p>4?1:p,o=a.slice(p),p+=t[1].length),h&&this.rules.other.blankLine.test(c)&&(s+=c+"\n",e=e.substring(c.length+1),n=!0),!n){const t=this.rules.other.nextBulletRegex(p),n=this.rules.other.hrRegex(p),r=this.rules.other.fencesBeginRegex(p),i=this.rules.other.headingBeginRegex(p),l=this.rules.other.htmlBeginRegex(p);for(;e;){const u=e.split("\n",1)[0];let g;if(c=u,this.options.pedantic?(c=c.replace(this.rules.other.listReplaceNesting,"  "),g=c):g=c.replace(this.rules.other.tabCharGlobal,"    "),r.test(c))break;if(i.test(c))break;if(l.test(c))break;if(t.test(c))break;if(n.test(c))break;if(g.search(this.rules.other.nonSpaceChar)>=p||!c.trim())o+="\n"+g.slice(p);else{if(h)break;if(a.replace(this.rules.other.tabCharGlobal,"    ").search(this.rules.other.nonSpaceChar)>=4)break;if(r.test(a))break;if(i.test(a))break;if(n.test(a))break;o+="\n"+c}h||c.trim()||(h=!0),s+=u+"\n",e=e.substring(u.length+1),a=g.slice(p)}}r.loose||(l?r.loose=!0:this.rules.other.doubleBlankLine.test(s)&&(l=!0));let u,g=null;this.options.gfm&&(g=this.rules.other.listIsTask.exec(o),g&&(u="[ ] "!==g[0],o=o.replace(this.rules.other.listReplaceTask,""))),r.items.push({type:"list_item",raw:s,task:!!g,checked:u,loose:!1,text:o,tokens:[]}),r.raw+=s}const o=r.items.at(-1);if(!o)return;o.raw=o.raw.trimEnd(),o.text=o.text.trimEnd(),r.raw=r.raw.trimEnd();for(let e=0;e<r.items.length;e++)if(this.lexer.state.top=!1,r.items[e].tokens=this.lexer.blockTokens(r.items[e].text,[]),!r.loose){const t=r.items[e].tokens.filter((e=>"space"===e.type)),n=t.length>0&&t.some((e=>this.rules.other.anyLine.test(e.raw)));r.loose=n}if(r.loose)for(let e=0;e<r.items.length;e++)r.items[e].loose=!0;return r}}html(e){const t=this.rules.block.html.exec(e);if(t){return{type:"html",block:!0,raw:t[0],pre:"pre"===t[1]||"script"===t[1]||"style"===t[1],text:t[0]}}}def(e){const t=this.rules.block.def.exec(e);if(t){const e=t[1].toLowerCase().replace(this.rules.other.multipleSpaceGlobal," "),n=t[2]?t[2].replace(this.rules.other.hrefBrackets,"$1").replace(this.rules.inline.anyPunctuation,"$1"):"",s=t[3]?t[3].substring(1,t[3].length-1).replace(this.rules.inline.anyPunctuation,"$1"):t[3];return{type:"def",tag:e,raw:t[0],href:n,title:s}}}table(e){const t=this.rules.block.table.exec(e);if(!t)return;if(!this.rules.other.tableDelimiter.test(t[2]))return;const n=U(t[1]),s=t[2].replace(this.rules.other.tableAlignChars,"").split("|"),r=t[3]?.trim()?t[3].replace(this.rules.other.tableRowBlankLine,"").split("\n"):[],i={type:"table",raw:t[0],header:[],align:[],rows:[]};if(n.length===s.length){for(const e of s)this.rules.other.tableAlignRight.test(e)?i.align.push("right"):this.rules.other.tableAlignCenter.test(e)?i.align.push("center"):this.rules.other.tableAlignLeft.test(e)?i.align.push("left"):i.align.push(null);for(let e=0;e<n.length;e++)i.header.push({text:n[e],tokens:this.lexer.inline(n[e]),header:!0,align:i.align[e]});for(const e of r)i.rows.push(U(e,i.header.length).map(((e,t)=>({text:e,tokens:this.lexer.inline(e),header:!1,align:i.align[t]}))));return i}}lheading(e){const t=this.rules.block.lheading.exec(e);if(t)return{type:"heading",raw:t[0],depth:"="===t[2].charAt(0)?1:2,text:t[1],tokens:this.lexer.inline(t[1])}}paragraph(e){const t=this.rules.block.paragraph.exec(e);if(t){const e="\n"===t[1].charAt(t[1].length-1)?t[1].slice(0,-1):t[1];return{type:"paragraph",raw:t[0],text:e,tokens:this.lexer.inline(e)}}}text(e){const t=this.rules.block.text.exec(e);if(t)return{type:"text",raw:t[0],text:t[0],tokens:this.lexer.inline(t[0])}}escape(e){const t=this.rules.inline.escape.exec(e);if(t)return{type:"escape",raw:t[0],text:t[1]}}tag(e){const t=this.rules.inline.tag.exec(e);if(t)return!this.lexer.state.inLink&&this.rules.other.startATag.test(t[0])?this.lexer.state.inLink=!0:this.lexer.state.inLink&&this.rules.other.endATag.test(t[0])&&(this.lexer.state.inLink=!1),!this.lexer.state.inRawBlock&&this.rules.other.startPreScriptTag.test(t[0])?this.lexer.state.inRawBlock=!0:this.lexer.state.inRawBlock&&this.rules.other.endPreScriptTag.test(t[0])&&(this.lexer.state.inRawBlock=!1),{type:"html",raw:t[0],inLink:this.lexer.state.inLink,inRawBlock:this.lexer.state.inRawBlock,block:!1,text:t[0]}}link(e){const t=this.rules.inline.link.exec(e);if(t){const e=t[2].trim();if(!this.options.pedantic&&this.rules.other.startAngleBracket.test(e)){if(!this.rules.other.endAngleBracket.test(e))return;const t=J(e.slice(0,-1),"\\");if((e.length-t.length)%2==0)return}else{const e=function(e,t){if(-1===e.indexOf(t[1]))return-1;let n=0;for(let s=0;s<e.length;s++)if("\\"===e[s])s++;else if(e[s]===t[0])n++;else if(e[s]===t[1]&&(n--,n<0))return s;return-1}(t[2],"()");if(e>-1){const n=(0===t[0].indexOf("!")?5:4)+t[1].length+e;t[2]=t[2].substring(0,e),t[0]=t[0].substring(0,n).trim(),t[3]=""}}let n=t[2],s="";if(this.options.pedantic){const e=this.rules.other.pedanticHrefTitle.exec(n);e&&(n=e[1],s=e[3])}else s=t[3]?t[3].slice(1,-1):"";return n=n.trim(),this.rules.other.startAngleBracket.test(n)&&(n=this.options.pedantic&&!this.rules.other.endAngleBracket.test(e)?n.slice(1):n.slice(1,-1)),K(t,{href:n?n.replace(this.rules.inline.anyPunctuation,"$1"):n,title:s?s.replace(this.rules.inline.anyPunctuation,"$1"):s},t[0],this.lexer,this.rules)}}reflink(e,t){let n;if((n=this.rules.inline.reflink.exec(e))||(n=this.rules.inline.nolink.exec(e))){const e=t[(n[2]||n[1]).replace(this.rules.other.multipleSpaceGlobal," ").toLowerCase()];if(!e){const e=n[0].charAt(0);return{type:"text",raw:e,text:e}}return K(n,e,n[0],this.lexer,this.rules)}}emStrong(e,t,n=""){let s=this.rules.inline.emStrongLDelim.exec(e);if(!s)return;if(s[3]&&n.match(this.rules.other.unicodeAlphaNumeric))return;if(!(s[1]||s[2]||"")||!n||this.rules.inline.punctuation.exec(n)){const n=[...s[0]].length-1;let r,i,l=n,o=0;const a="*"===s[0][0]?this.rules.inline.emStrongRDelimAst:this.rules.inline.emStrongRDelimUnd;for(a.lastIndex=0,t=t.slice(-1*e.length+n);null!=(s=a.exec(t));){if(r=s[1]||s[2]||s[3]||s[4]||s[5]||s[6],!r)continue;if(i=[...r].length,s[3]||s[4]){l+=i;continue}if((s[5]||s[6])&&n%3&&!((n+i)%3)){o+=i;continue}if(l-=i,l>0)continue;i=Math.min(i,i+l+o);const t=[...s[0]][0].length,a=e.slice(0,n+s.index+t+i);if(Math.min(n,i)%2){const e=a.slice(1,-1);return{type:"em",raw:a,text:e,tokens:this.lexer.inlineTokens(e)}}const c=a.slice(2,-2);return{type:"strong",raw:a,text:c,tokens:this.lexer.inlineTokens(c)}}}}codespan(e){const t=this.rules.inline.code.exec(e);if(t){let e=t[2].replace(this.rules.other.newLineCharGlobal," ");const n=this.rules.other.nonSpaceChar.test(e),s=this.rules.other.startingSpaceChar.test(e)&&this.rules.other.endingSpaceChar.test(e);return n&&s&&(e=e.substring(1,e.length-1)),{type:"codespan",raw:t[0],text:e}}}br(e){const t=this.rules.inline.br.exec(e);if(t)return{type:"br",raw:t[0]}}del(e){const t=this.rules.inline.del.exec(e);if(t)return{type:"del",raw:t[0],text:t[2],tokens:this.lexer.inlineTokens(t[2])}}autolink(e){const t=this.rules.inline.autolink.exec(e);if(t){let e,n;return"@"===t[2]?(e=t[1],n="mailto:"+e):(e=t[1],n=e),{type:"link",raw:t[0],text:e,href:n,tokens:[{type:"text",raw:e,text:e}]}}}url(e){let t;if(t=this.rules.inline.url.exec(e)){let e,n;if("@"===t[2])e=t[0],n="mailto:"+e;else{let s;do{s=t[0],t[0]=this.rules.inline._backpedal.exec(t[0])?.[0]??""}while(s!==t[0]);e=t[0],n="www."===t[1]?"http://"+t[0]:t[0]}return{type:"link",raw:t[0],text:e,href:n,tokens:[{type:"text",raw:e,text:e}]}}}inlineText(e){const t=this.rules.inline.text.exec(e);if(t){const e=this.lexer.state.inRawBlock;return{type:"text",raw:t[0],text:t[0],escaped:e}}}}class W{tokens;options;state;tokenizer;inlineQueue;constructor(t){this.tokens=[],this.tokens.links=Object.create(null),this.options=t||e.defaults,this.options.tokenizer=this.options.tokenizer||new V,this.tokenizer=this.options.tokenizer,this.tokenizer.options=this.options,this.tokenizer.lexer=this,this.inlineQueue=[],this.state={inLink:!1,inRawBlock:!1,top:!0};const n={other:i,block:j.normal,inline:N.normal};this.options.pedantic?(n.block=j.pedantic,n.inline=N.pedantic):this.options.gfm&&(n.block=j.gfm,this.options.breaks?n.inline=N.breaks:n.inline=N.gfm),this.tokenizer.rules=n}static get rules(){return{block:j,inline:N}}static lex(e,t){return new W(t).lex(e)}static lexInline(e,t){return new W(t).inlineTokens(e)}lex(e){e=e.replace(i.carriageReturn,"\n"),this.blockTokens(e,this.tokens);for(let e=0;e<this.inlineQueue.length;e++){const t=this.inlineQueue[e];this.inlineTokens(t.src,t.tokens)}return this.inlineQueue=[],this.tokens}blockTokens(e,t=[],n=!1){for(this.options.pedantic&&(e=e.replace(i.tabCharGlobal,"    ").replace(i.spaceLine,""));e;){let s;if(this.options.extensions?.block?.some((n=>!!(s=n.call({lexer:this},e,t))&&(e=e.substring(s.raw.length),t.push(s),!0))))continue;if(s=this.tokenizer.space(e)){e=e.substring(s.raw.length);const n=t.at(-1);1===s.raw.length&&void 0!==n?n.raw+="\n":t.push(s);continue}if(s=this.tokenizer.code(e)){e=e.substring(s.raw.length);const n=t.at(-1);"paragraph"===n?.type||"text"===n?.type?(n.raw+="\n"+s.raw,n.text+="\n"+s.text,this.inlineQueue.at(-1).src=n.text):t.push(s);continue}if(s=this.tokenizer.fences(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.heading(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.hr(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.blockquote(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.list(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.html(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.def(e)){e=e.substring(s.raw.length);const n=t.at(-1);"paragraph"===n?.type||"text"===n?.type?(n.raw+="\n"+s.raw,n.text+="\n"+s.raw,this.inlineQueue.at(-1).src=n.text):this.tokens.links[s.tag]||(this.tokens.links[s.tag]={href:s.href,title:s.title});continue}if(s=this.tokenizer.table(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.lheading(e)){e=e.substring(s.raw.length),t.push(s);continue}let r=e;if(this.options.extensions?.startBlock){let t=1/0;const n=e.slice(1);let s;this.options.extensions.startBlock.forEach((e=>{s=e.call({lexer:this},n),"number"==typeof s&&s>=0&&(t=Math.min(t,s))})),t<1/0&&t>=0&&(r=e.substring(0,t+1))}if(this.state.top&&(s=this.tokenizer.paragraph(r))){const i=t.at(-1);n&&"paragraph"===i?.type?(i.raw+="\n"+s.raw,i.text+="\n"+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=i.text):t.push(s),n=r.length!==e.length,e=e.substring(s.raw.length)}else if(s=this.tokenizer.text(e)){e=e.substring(s.raw.length);const n=t.at(-1);"text"===n?.type?(n.raw+="\n"+s.raw,n.text+="\n"+s.text,this.inlineQueue.pop(),this.inlineQueue.at(-1).src=n.text):t.push(s)}else if(e){const t="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(t);break}throw new Error(t)}}return this.state.top=!0,t}inline(e,t=[]){return this.inlineQueue.push({src:e,tokens:t}),t}inlineTokens(e,t=[]){let n=e,s=null;if(this.tokens.links){const e=Object.keys(this.tokens.links);if(e.length>0)for(;null!=(s=this.tokenizer.rules.inline.reflinkSearch.exec(n));)e.includes(s[0].slice(s[0].lastIndexOf("[")+1,-1))&&(n=n.slice(0,s.index)+"["+"a".repeat(s[0].length-2)+"]"+n.slice(this.tokenizer.rules.inline.reflinkSearch.lastIndex))}for(;null!=(s=this.tokenizer.rules.inline.blockSkip.exec(n));)n=n.slice(0,s.index)+"["+"a".repeat(s[0].length-2)+"]"+n.slice(this.tokenizer.rules.inline.blockSkip.lastIndex);for(;null!=(s=this.tokenizer.rules.inline.anyPunctuation.exec(n));)n=n.slice(0,s.index)+"++"+n.slice(this.tokenizer.rules.inline.anyPunctuation.lastIndex);let r=!1,i="";for(;e;){let s;if(r||(i=""),r=!1,this.options.extensions?.inline?.some((n=>!!(s=n.call({lexer:this},e,t))&&(e=e.substring(s.raw.length),t.push(s),!0))))continue;if(s=this.tokenizer.escape(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.tag(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.link(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.reflink(e,this.tokens.links)){e=e.substring(s.raw.length);const n=t.at(-1);"text"===s.type&&"text"===n?.type?(n.raw+=s.raw,n.text+=s.text):t.push(s);continue}if(s=this.tokenizer.emStrong(e,n,i)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.codespan(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.br(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.del(e)){e=e.substring(s.raw.length),t.push(s);continue}if(s=this.tokenizer.autolink(e)){e=e.substring(s.raw.length),t.push(s);continue}if(!this.state.inLink&&(s=this.tokenizer.url(e))){e=e.substring(s.raw.length),t.push(s);continue}let l=e;if(this.options.extensions?.startInline){let t=1/0;const n=e.slice(1);let s;this.options.extensions.startInline.forEach((e=>{s=e.call({lexer:this},n),"number"==typeof s&&s>=0&&(t=Math.min(t,s))})),t<1/0&&t>=0&&(l=e.substring(0,t+1))}if(s=this.tokenizer.inlineText(l)){e=e.substring(s.raw.length),"_"!==s.raw.slice(-1)&&(i=s.raw.slice(-1)),r=!0;const n=t.at(-1);"text"===n?.type?(n.raw+=s.raw,n.text+=s.text):t.push(s)}else if(e){const t="Infinite loop on byte: "+e.charCodeAt(0);if(this.options.silent){console.error(t);break}throw new Error(t)}}return t}}class Y{options;parser;constructor(t){this.options=t||e.defaults}space(e){return""}code({text:e,lang:t,escaped:n}){const s=(t||"").match(i.notSpaceStart)?.[0],r=e.replace(i.endingNewline,"")+"\n";return s?'<pre><code class="language-'+X(s)+'">'+(n?r:X(r,!0))+"</code></pre>\n":"<pre><code>"+(n?r:X(r,!0))+"</code></pre>\n"}blockquote({tokens:e}){return`<blockquote>\n${this.parser.parse(e)}</blockquote>\n`}html({text:e}){return e}heading({tokens:e,depth:t}){return`<h${t}>${this.parser.parseInline(e)}</h${t}>\n`}hr(e){return"<hr>\n"}list(e){const t=e.ordered,n=e.start;let s="";for(let t=0;t<e.items.length;t++){const n=e.items[t];s+=this.listitem(n)}const r=t?"ol":"ul";return"<"+r+(t&&1!==n?' start="'+n+'"':"")+">\n"+s+"</"+r+">\n"}listitem(e){let t="";if(e.task){const n=this.checkbox({checked:!!e.checked});e.loose?"paragraph"===e.tokens[0]?.type?(e.tokens[0].text=n+" "+e.tokens[0].text,e.tokens[0].tokens&&e.tokens[0].tokens.length>0&&"text"===e.tokens[0].tokens[0].type&&(e.tokens[0].tokens[0].text=n+" "+X(e.tokens[0].tokens[0].text),e.tokens[0].tokens[0].escaped=!0)):e.tokens.unshift({type:"text",raw:n+" ",text:n+" ",escaped:!0}):t+=n+" "}return t+=this.parser.parse(e.tokens,!!e.loose),`<li>${t}</li>\n`}checkbox({checked:e}){return"<input "+(e?'checked="" ':"")+'disabled="" type="checkbox">'}paragraph({tokens:e}){return`<p>${this.parser.parseInline(e)}</p>\n`}table(e){let t="",n="";for(let t=0;t<e.header.length;t++)n+=this.tablecell(e.header[t]);t+=this.tablerow({text:n});let s="";for(let t=0;t<e.rows.length;t++){const r=e.rows[t];n="";for(let e=0;e<r.length;e++)n+=this.tablecell(r[e]);s+=this.tablerow({text:n})}return s&&(s=`<tbody>${s}</tbody>`),"<table>\n<thead>\n"+t+"</thead>\n"+s+"</table>\n"}tablerow({text:e}){return`<tr>\n${e}</tr>\n`}tablecell(e){const t=this.parser.parseInline(e.tokens),n=e.header?"th":"td";return(e.align?`<${n} align="${e.align}">`:`<${n}>`)+t+`</${n}>\n`}strong({tokens:e}){return`<strong>${this.parser.parseInline(e)}</strong>`}em({tokens:e}){return`<em>${this.parser.parseInline(e)}</em>`}codespan({text:e}){return`<code>${X(e,!0)}</code>`}br(e){return"<br>"}del({tokens:e}){return`<del>${this.parser.parseInline(e)}</del>`}link({href:e,title:t,tokens:n}){const s=this.parser.parseInline(n),r=F(e);if(null===r)return s;let i='<a href="'+(e=r)+'"';return t&&(i+=' title="'+X(t)+'"'),i+=">"+s+"</a>",i}image({href:e,title:t,text:n}){const s=F(e);if(null===s)return X(n);let r=`<img src="${e=s}" alt="${n}"`;return t&&(r+=` title="${X(t)}"`),r+=">",r}text(e){return"tokens"in e&&e.tokens?this.parser.parseInline(e.tokens):"escaped"in e&&e.escaped?e.text:X(e.text)}}class ee{strong({text:e}){return e}em({text:e}){return e}codespan({text:e}){return e}del({text:e}){return e}html({text:e}){return e}text({text:e}){return e}link({text:e}){return""+e}image({text:e}){return""+e}br(){return""}}class te{options;renderer;textRenderer;constructor(t){this.options=t||e.defaults,this.options.renderer=this.options.renderer||new Y,this.renderer=this.options.renderer,this.renderer.options=this.options,this.renderer.parser=this,this.textRenderer=new ee}static parse(e,t){return new te(t).parse(e)}static parseInline(e,t){return new te(t).parseInline(e)}parse(e,t=!0){let n="";for(let s=0;s<e.length;s++){const r=e[s];if(this.options.extensions?.renderers?.[r.type]){const e=r,t=this.options.extensions.renderers[e.type].call({parser:this},e);if(!1!==t||!["space","hr","heading","code","table","blockquote","list","html","paragraph","text"].includes(e.type)){n+=t||"";continue}}const i=r;switch(i.type){case"space":n+=this.renderer.space(i);continue;case"hr":n+=this.renderer.hr(i);continue;case"heading":n+=this.renderer.heading(i);continue;case"code":n+=this.renderer.code(i);continue;case"table":n+=this.renderer.table(i);continue;case"blockquote":n+=this.renderer.blockquote(i);continue;case"list":n+=this.renderer.list(i);continue;case"html":n+=this.renderer.html(i);continue;case"paragraph":n+=this.renderer.paragraph(i);continue;case"text":{let r=i,l=this.renderer.text(r);for(;s+1<e.length&&"text"===e[s+1].type;)r=e[++s],l+="\n"+this.renderer.text(r);n+=t?this.renderer.paragraph({type:"paragraph",raw:l,text:l,tokens:[{type:"text",raw:l,text:l,escaped:!0}]}):l;continue}default:{const e='Token with "'+i.type+'" type was not found.';if(this.options.silent)return console.error(e),"";throw new Error(e)}}}return n}parseInline(e,t=this.renderer){let n="";for(let s=0;s<e.length;s++){const r=e[s];if(this.options.extensions?.renderers?.[r.type]){const e=this.options.extensions.renderers[r.type].call({parser:this},r);if(!1!==e||!["escape","html","link","image","strong","em","codespan","br","del","text"].includes(r.type)){n+=e||"";continue}}const i=r;switch(i.type){case"escape":case"text":n+=t.text(i);break;case"html":n+=t.html(i);break;case"link":n+=t.link(i);break;case"image":n+=t.image(i);break;case"strong":n+=t.strong(i);break;case"em":n+=t.em(i);break;case"codespan":n+=t.codespan(i);break;case"br":n+=t.br(i);break;case"del":n+=t.del(i);break;default:{const e='Token with "'+i.type+'" type was not found.';if(this.options.silent)return console.error(e),"";throw new Error(e)}}}return n}}class ne{options;block;constructor(t){this.options=t||e.defaults}static passThroughHooks=new Set(["preprocess","postprocess","processAllTokens"]);preprocess(e){return e}postprocess(e){return e}processAllTokens(e){return e}provideLexer(){return this.block?W.lex:W.lexInline}provideParser(){return this.block?te.parse:te.parseInline}}class se{defaults={async:!1,breaks:!1,extensions:null,gfm:!0,hooks:null,pedantic:!1,renderer:null,silent:!1,tokenizer:null,walkTokens:null};options=this.setOptions;parse=this.parseMarkdown(!0);parseInline=this.parseMarkdown(!1);Parser=te;Renderer=Y;TextRenderer=ee;Lexer=W;Tokenizer=V;Hooks=ne;constructor(...e){this.use(...e)}walkTokens(e,t){let n=[];for(const s of e)switch(n=n.concat(t.call(this,s)),s.type){case"table":{const e=s;for(const s of e.header)n=n.concat(this.walkTokens(s.tokens,t));for(const s of e.rows)for(const e of s)n=n.concat(this.walkTokens(e.tokens,t));break}case"list":{const e=s;n=n.concat(this.walkTokens(e.items,t));break}default:{const e=s;this.defaults.extensions?.childTokens?.[e.type]?this.defaults.extensions.childTokens[e.type].forEach((s=>{const r=e[s].flat(1/0);n=n.concat(this.walkTokens(r,t))})):e.tokens&&(n=n.concat(this.walkTokens(e.tokens,t)))}}return n}use(...e){const t=this.defaults.extensions||{renderers:{},childTokens:{}};return e.forEach((e=>{const n={...e};if(n.async=this.defaults.async||n.async||!1,e.extensions&&(e.extensions.forEach((e=>{if(!e.name)throw new Error("extension name required");if("renderer"in e){const n=t.renderers[e.name];t.renderers[e.name]=n?function(...t){let s=e.renderer.apply(this,t);return!1===s&&(s=n.apply(this,t)),s}:e.renderer}if("tokenizer"in e){if(!e.level||"block"!==e.level&&"inline"!==e.level)throw new Error("extension level must be 'block' or 'inline'");const n=t[e.level];n?n.unshift(e.tokenizer):t[e.level]=[e.tokenizer],e.start&&("block"===e.level?t.startBlock?t.startBlock.push(e.start):t.startBlock=[e.start]:"inline"===e.level&&(t.startInline?t.startInline.push(e.start):t.startInline=[e.start]))}"childTokens"in e&&e.childTokens&&(t.childTokens[e.name]=e.childTokens)})),n.extensions=t),e.renderer){const t=this.defaults.renderer||new Y(this.defaults);for(const n in e.renderer){if(!(n in t))throw new Error(`renderer '${n}' does not exist`);if(["options","parser"].includes(n))continue;const s=n,r=e.renderer[s],i=t[s];t[s]=(...e)=>{let n=r.apply(t,e);return!1===n&&(n=i.apply(t,e)),n||""}}n.renderer=t}if(e.tokenizer){const t=this.defaults.tokenizer||new V(this.defaults);for(const n in e.tokenizer){if(!(n in t))throw new Error(`tokenizer '${n}' does not exist`);if(["options","rules","lexer"].includes(n))continue;const s=n,r=e.tokenizer[s],i=t[s];t[s]=(...e)=>{let n=r.apply(t,e);return!1===n&&(n=i.apply(t,e)),n}}n.tokenizer=t}if(e.hooks){const t=this.defaults.hooks||new ne;for(const n in e.hooks){if(!(n in t))throw new Error(`hook '${n}' does not exist`);if(["options","block"].includes(n))continue;const s=n,r=e.hooks[s],i=t[s];ne.passThroughHooks.has(n)?t[s]=e=>{if(this.defaults.async)return Promise.resolve(r.call(t,e)).then((e=>i.call(t,e)));const n=r.call(t,e);return i.call(t,n)}:t[s]=(...e)=>{let n=r.apply(t,e);return!1===n&&(n=i.apply(t,e)),n}}n.hooks=t}if(e.walkTokens){const t=this.defaults.walkTokens,s=e.walkTokens;n.walkTokens=function(e){let n=[];return n.push(s.call(this,e)),t&&(n=n.concat(t.call(this,e))),n}}this.defaults={...this.defaults,...n}})),this}setOptions(e){return this.defaults={...this.defaults,...e},this}lexer(e,t){return W.lex(e,t??this.defaults)}parser(e,t){return te.parse(e,t??this.defaults)}parseMarkdown(e){return(t,n)=>{const s={...n},r={...this.defaults,...s},i=this.onError(!!r.silent,!!r.async);if(!0===this.defaults.async&&!1===s.async)return i(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));if(null==t)return i(new Error("marked(): input parameter is undefined or null"));if("string"!=typeof t)return i(new Error("marked(): input parameter is of type "+Object.prototype.toString.call(t)+", string expected"));r.hooks&&(r.hooks.options=r,r.hooks.block=e);const l=r.hooks?r.hooks.provideLexer():e?W.lex:W.lexInline,o=r.hooks?r.hooks.provideParser():e?te.parse:te.parseInline;if(r.async)return Promise.resolve(r.hooks?r.hooks.preprocess(t):t).then((e=>l(e,r))).then((e=>r.hooks?r.hooks.processAllTokens(e):e)).then((e=>r.walkTokens?Promise.all(this.walkTokens(e,r.walkTokens)).then((()=>e)):e)).then((e=>o(e,r))).then((e=>r.hooks?r.hooks.postprocess(e):e)).catch(i);try{r.hooks&&(t=r.hooks.preprocess(t));let e=l(t,r);r.hooks&&(e=r.hooks.processAllTokens(e)),r.walkTokens&&this.walkTokens(e,r.walkTokens);let n=o(e,r);return r.hooks&&(n=r.hooks.postprocess(n)),n}catch(e){return i(e)}}}onError(e,t){return n=>{if(n.message+="\nPlease report this to https://github.com/markedjs/marked.",e){const e="<p>An error occurred:</p><pre>"+X(n.message+"",!0)+"</pre>";return t?Promise.resolve(e):e}if(t)return Promise.reject(n);throw n}}}const re=new se;function ie(e,t){return re.parse(e,t)}ie.options=ie.setOptions=function(e){return re.setOptions(e),ie.defaults=re.defaults,n(ie.defaults),ie},ie.getDefaults=t,ie.defaults=e.defaults,ie.use=function(...e){return re.use(...e),ie.defaults=re.defaults,n(ie.defaults),ie},ie.walkTokens=function(e,t){return re.walkTokens(e,t)},ie.parseInline=re.parseInline,ie.Parser=te,ie.parser=te.parse,ie.Renderer=Y,ie.TextRenderer=ee,ie.Lexer=W,ie.lexer=W.lex,ie.Tokenizer=V,ie.Hooks=ne,ie.parse=ie;const le=ie.options,oe=ie.setOptions,ae=ie.use,ce=ie.walkTokens,he=ie.parseInline,pe=ie,ue=te.parse,ge=W.lex;e.Hooks=ne,e.Lexer=W,e.Marked=se,e.Parser=te,e.Renderer=Y,e.TextRenderer=ee,e.Tokenizer=V,e.getDefaults=t,e.lexer=ge,e.marked=ie,e.options=le,e.parse=pe,e.parseInline=he,e.parser=ue,e.setOptions=oe,e.use=ae,e.walkTokens=ce}));
+</script>
+
+  <!-- highlight.js -->
+  <script>/*!
+  Highlight.js v11.9.0 (git: f47103d4f1)
+  (c) 2006-2023 undefined and other contributors
+  License: BSD-3-Clause
+ */
+var hljs=function(){"use strict";function e(n){
+return n instanceof Map?n.clear=n.delete=n.set=()=>{
+throw Error("map is read-only")}:n instanceof Set&&(n.add=n.clear=n.delete=()=>{
+throw Error("set is read-only")
+}),Object.freeze(n),Object.getOwnPropertyNames(n).forEach((t=>{
+const a=n[t],i=typeof a;"object"!==i&&"function"!==i||Object.isFrozen(a)||e(a)
+})),n}class n{constructor(e){
+void 0===e.data&&(e.data={}),this.data=e.data,this.isMatchIgnored=!1}
+ignoreMatch(){this.isMatchIgnored=!0}}function t(e){
+return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;").replace(/'/g,"&#x27;")
+}function a(e,...n){const t=Object.create(null);for(const n in e)t[n]=e[n]
+;return n.forEach((e=>{for(const n in e)t[n]=e[n]})),t}const i=e=>!!e.scope
+;class r{constructor(e,n){
+this.buffer="",this.classPrefix=n.classPrefix,e.walk(this)}addText(e){
+this.buffer+=t(e)}openNode(e){if(!i(e))return;const n=((e,{prefix:n})=>{
+if(e.startsWith("language:"))return e.replace("language:","language-")
+;if(e.includes(".")){const t=e.split(".")
+;return[`${n}${t.shift()}`,...t.map(((e,n)=>`${e}${"_".repeat(n+1)}`))].join(" ")
+}return`${n}${e}`})(e.scope,{prefix:this.classPrefix});this.span(n)}
+closeNode(e){i(e)&&(this.buffer+="</span>")}value(){return this.buffer}span(e){
+this.buffer+=`<span class="${e}">`}}const s=(e={})=>{const n={children:[]}
+;return Object.assign(n,e),n};class o{constructor(){
+this.rootNode=s(),this.stack=[this.rootNode]}get top(){
+return this.stack[this.stack.length-1]}get root(){return this.rootNode}add(e){
+this.top.children.push(e)}openNode(e){const n=s({scope:e})
+;this.add(n),this.stack.push(n)}closeNode(){
+if(this.stack.length>1)return this.stack.pop()}closeAllNodes(){
+for(;this.closeNode(););}toJSON(){return JSON.stringify(this.rootNode,null,4)}
+walk(e){return this.constructor._walk(e,this.rootNode)}static _walk(e,n){
+return"string"==typeof n?e.addText(n):n.children&&(e.openNode(n),
+n.children.forEach((n=>this._walk(e,n))),e.closeNode(n)),e}static _collapse(e){
+"string"!=typeof e&&e.children&&(e.children.every((e=>"string"==typeof e))?e.children=[e.children.join("")]:e.children.forEach((e=>{
+o._collapse(e)})))}}class l extends o{constructor(e){super(),this.options=e}
+addText(e){""!==e&&this.add(e)}startScope(e){this.openNode(e)}endScope(){
+this.closeNode()}__addSublanguage(e,n){const t=e.root
+;n&&(t.scope="language:"+n),this.add(t)}toHTML(){
+return new r(this,this.options).value()}finalize(){
+return this.closeAllNodes(),!0}}function c(e){
+return e?"string"==typeof e?e:e.source:null}function d(e){return b("(?=",e,")")}
+function g(e){return b("(?:",e,")*")}function u(e){return b("(?:",e,")?")}
+function b(...e){return e.map((e=>c(e))).join("")}function m(...e){const n=(e=>{
+const n=e[e.length-1]
+;return"object"==typeof n&&n.constructor===Object?(e.splice(e.length-1,1),n):{}
+})(e);return"("+(n.capture?"":"?:")+e.map((e=>c(e))).join("|")+")"}
+function p(e){return RegExp(e.toString()+"|").exec("").length-1}
+const _=/\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
+;function h(e,{joinWith:n}){let t=0;return e.map((e=>{t+=1;const n=t
+;let a=c(e),i="";for(;a.length>0;){const e=_.exec(a);if(!e){i+=a;break}
+i+=a.substring(0,e.index),
+a=a.substring(e.index+e[0].length),"\\"===e[0][0]&&e[1]?i+="\\"+(Number(e[1])+n):(i+=e[0],
+"("===e[0]&&t++)}return i})).map((e=>`(${e})`)).join(n)}
+const f="[a-zA-Z]\\w*",E="[a-zA-Z_]\\w*",y="\\b\\d+(\\.\\d+)?",N="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",w="\\b(0b[01]+)",v={
+begin:"\\\\[\\s\\S]",relevance:0},O={scope:"string",begin:"'",end:"'",
+illegal:"\\n",contains:[v]},k={scope:"string",begin:'"',end:'"',illegal:"\\n",
+contains:[v]},x=(e,n,t={})=>{const i=a({scope:"comment",begin:e,end:n,
+contains:[]},t);i.contains.push({scope:"doctag",
+begin:"[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
+end:/(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/,excludeBegin:!0,relevance:0})
+;const r=m("I","a","is","so","us","to","at","if","in","it","on",/[A-Za-z]+['](d|ve|re|ll|t|s|n)/,/[A-Za-z]+[-][a-z]+/,/[A-Za-z][a-z]{2,}/)
+;return i.contains.push({begin:b(/[ ]+/,"(",r,/[.]?[:]?([.][ ]|[ ])/,"){3}")}),i
+},M=x("//","$"),S=x("/\\*","\\*/"),A=x("#","$");var C=Object.freeze({
+__proto__:null,APOS_STRING_MODE:O,BACKSLASH_ESCAPE:v,BINARY_NUMBER_MODE:{
+scope:"number",begin:w,relevance:0},BINARY_NUMBER_RE:w,COMMENT:x,
+C_BLOCK_COMMENT_MODE:S,C_LINE_COMMENT_MODE:M,C_NUMBER_MODE:{scope:"number",
+begin:N,relevance:0},C_NUMBER_RE:N,END_SAME_AS_BEGIN:e=>Object.assign(e,{
+"on:begin":(e,n)=>{n.data._beginMatch=e[1]},"on:end":(e,n)=>{
+n.data._beginMatch!==e[1]&&n.ignoreMatch()}}),HASH_COMMENT_MODE:A,IDENT_RE:f,
+MATCH_NOTHING_RE:/\b\B/,METHOD_GUARD:{begin:"\\.\\s*"+E,relevance:0},
+NUMBER_MODE:{scope:"number",begin:y,relevance:0},NUMBER_RE:y,
+PHRASAL_WORDS_MODE:{
+begin:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
+},QUOTE_STRING_MODE:k,REGEXP_MODE:{scope:"regexp",begin:/\/(?=[^/\n]*\/)/,
+end:/\/[gimuy]*/,contains:[v,{begin:/\[/,end:/\]/,relevance:0,contains:[v]}]},
+RE_STARTERS_RE:"!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
+SHEBANG:(e={})=>{const n=/^#![ ]*\//
+;return e.binary&&(e.begin=b(n,/.*\b/,e.binary,/\b.*/)),a({scope:"meta",begin:n,
+end:/$/,relevance:0,"on:begin":(e,n)=>{0!==e.index&&n.ignoreMatch()}},e)},
+TITLE_MODE:{scope:"title",begin:f,relevance:0},UNDERSCORE_IDENT_RE:E,
+UNDERSCORE_TITLE_MODE:{scope:"title",begin:E,relevance:0}});function T(e,n){
+"."===e.input[e.index-1]&&n.ignoreMatch()}function R(e,n){
+void 0!==e.className&&(e.scope=e.className,delete e.className)}function D(e,n){
+n&&e.beginKeywords&&(e.begin="\\b("+e.beginKeywords.split(" ").join("|")+")(?!\\.)(?=\\b|\\s)",
+e.__beforeBegin=T,e.keywords=e.keywords||e.beginKeywords,delete e.beginKeywords,
+void 0===e.relevance&&(e.relevance=0))}function I(e,n){
+Array.isArray(e.illegal)&&(e.illegal=m(...e.illegal))}function L(e,n){
+if(e.match){
+if(e.begin||e.end)throw Error("begin & end are not supported with match")
+;e.begin=e.match,delete e.match}}function B(e,n){
+void 0===e.relevance&&(e.relevance=1)}const $=(e,n)=>{if(!e.beforeMatch)return
+;if(e.starts)throw Error("beforeMatch cannot be used with starts")
+;const t=Object.assign({},e);Object.keys(e).forEach((n=>{delete e[n]
+})),e.keywords=t.keywords,e.begin=b(t.beforeMatch,d(t.begin)),e.starts={
+relevance:0,contains:[Object.assign(t,{endsParent:!0})]
+},e.relevance=0,delete t.beforeMatch
+},z=["of","and","for","in","not","or","if","then","parent","list","value"],F="keyword"
+;function U(e,n,t=F){const a=Object.create(null)
+;return"string"==typeof e?i(t,e.split(" ")):Array.isArray(e)?i(t,e):Object.keys(e).forEach((t=>{
+Object.assign(a,U(e[t],n,t))})),a;function i(e,t){
+n&&(t=t.map((e=>e.toLowerCase()))),t.forEach((n=>{const t=n.split("|")
+;a[t[0]]=[e,j(t[0],t[1])]}))}}function j(e,n){
+return n?Number(n):(e=>z.includes(e.toLowerCase()))(e)?0:1}const P={},K=e=>{
+console.error(e)},H=(e,...n)=>{console.log("WARN: "+e,...n)},q=(e,n)=>{
+P[`${e}/${n}`]||(console.log(`Deprecated as of ${e}. ${n}`),P[`${e}/${n}`]=!0)
+},G=Error();function Z(e,n,{key:t}){let a=0;const i=e[t],r={},s={}
+;for(let e=1;e<=n.length;e++)s[e+a]=i[e],r[e+a]=!0,a+=p(n[e-1])
+;e[t]=s,e[t]._emit=r,e[t]._multi=!0}function W(e){(e=>{
+e.scope&&"object"==typeof e.scope&&null!==e.scope&&(e.beginScope=e.scope,
+delete e.scope)})(e),"string"==typeof e.beginScope&&(e.beginScope={
+_wrap:e.beginScope}),"string"==typeof e.endScope&&(e.endScope={_wrap:e.endScope
+}),(e=>{if(Array.isArray(e.begin)){
+if(e.skip||e.excludeBegin||e.returnBegin)throw K("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
+G
+;if("object"!=typeof e.beginScope||null===e.beginScope)throw K("beginScope must be object"),
+G;Z(e,e.begin,{key:"beginScope"}),e.begin=h(e.begin,{joinWith:""})}})(e),(e=>{
+if(Array.isArray(e.end)){
+if(e.skip||e.excludeEnd||e.returnEnd)throw K("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
+G
+;if("object"!=typeof e.endScope||null===e.endScope)throw K("endScope must be object"),
+G;Z(e,e.end,{key:"endScope"}),e.end=h(e.end,{joinWith:""})}})(e)}function Q(e){
+function n(n,t){
+return RegExp(c(n),"m"+(e.case_insensitive?"i":"")+(e.unicodeRegex?"u":"")+(t?"g":""))
+}class t{constructor(){
+this.matchIndexes={},this.regexes=[],this.matchAt=1,this.position=0}
+addRule(e,n){
+n.position=this.position++,this.matchIndexes[this.matchAt]=n,this.regexes.push([n,e]),
+this.matchAt+=p(e)+1}compile(){0===this.regexes.length&&(this.exec=()=>null)
+;const e=this.regexes.map((e=>e[1]));this.matcherRe=n(h(e,{joinWith:"|"
+}),!0),this.lastIndex=0}exec(e){this.matcherRe.lastIndex=this.lastIndex
+;const n=this.matcherRe.exec(e);if(!n)return null
+;const t=n.findIndex(((e,n)=>n>0&&void 0!==e)),a=this.matchIndexes[t]
+;return n.splice(0,t),Object.assign(n,a)}}class i{constructor(){
+this.rules=[],this.multiRegexes=[],
+this.count=0,this.lastIndex=0,this.regexIndex=0}getMatcher(e){
+if(this.multiRegexes[e])return this.multiRegexes[e];const n=new t
+;return this.rules.slice(e).forEach((([e,t])=>n.addRule(e,t))),
+n.compile(),this.multiRegexes[e]=n,n}resumingScanAtSamePosition(){
+return 0!==this.regexIndex}considerAll(){this.regexIndex=0}addRule(e,n){
+this.rules.push([e,n]),"begin"===n.type&&this.count++}exec(e){
+const n=this.getMatcher(this.regexIndex);n.lastIndex=this.lastIndex
+;let t=n.exec(e)
+;if(this.resumingScanAtSamePosition())if(t&&t.index===this.lastIndex);else{
+const n=this.getMatcher(0);n.lastIndex=this.lastIndex+1,t=n.exec(e)}
+return t&&(this.regexIndex+=t.position+1,
+this.regexIndex===this.count&&this.considerAll()),t}}
+if(e.compilerExtensions||(e.compilerExtensions=[]),
+e.contains&&e.contains.includes("self"))throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
+;return e.classNameAliases=a(e.classNameAliases||{}),function t(r,s){const o=r
+;if(r.isCompiled)return o
+;[R,L,W,$].forEach((e=>e(r,s))),e.compilerExtensions.forEach((e=>e(r,s))),
+r.__beforeBegin=null,[D,I,B].forEach((e=>e(r,s))),r.isCompiled=!0;let l=null
+;return"object"==typeof r.keywords&&r.keywords.$pattern&&(r.keywords=Object.assign({},r.keywords),
+l=r.keywords.$pattern,
+delete r.keywords.$pattern),l=l||/\w+/,r.keywords&&(r.keywords=U(r.keywords,e.case_insensitive)),
+o.keywordPatternRe=n(l,!0),
+s&&(r.begin||(r.begin=/\B|\b/),o.beginRe=n(o.begin),r.end||r.endsWithParent||(r.end=/\B|\b/),
+r.end&&(o.endRe=n(o.end)),
+o.terminatorEnd=c(o.end)||"",r.endsWithParent&&s.terminatorEnd&&(o.terminatorEnd+=(r.end?"|":"")+s.terminatorEnd)),
+r.illegal&&(o.illegalRe=n(r.illegal)),
+r.contains||(r.contains=[]),r.contains=[].concat(...r.contains.map((e=>(e=>(e.variants&&!e.cachedVariants&&(e.cachedVariants=e.variants.map((n=>a(e,{
+variants:null},n)))),e.cachedVariants?e.cachedVariants:X(e)?a(e,{
+starts:e.starts?a(e.starts):null
+}):Object.isFrozen(e)?a(e):e))("self"===e?r:e)))),r.contains.forEach((e=>{t(e,o)
+})),r.starts&&t(r.starts,s),o.matcher=(e=>{const n=new i
+;return e.contains.forEach((e=>n.addRule(e.begin,{rule:e,type:"begin"
+}))),e.terminatorEnd&&n.addRule(e.terminatorEnd,{type:"end"
+}),e.illegal&&n.addRule(e.illegal,{type:"illegal"}),n})(o),o}(e)}function X(e){
+return!!e&&(e.endsWithParent||X(e.starts))}class V extends Error{
+constructor(e,n){super(e),this.name="HTMLInjectionError",this.html=n}}
+const J=t,Y=a,ee=Symbol("nomatch"),ne=t=>{
+const a=Object.create(null),i=Object.create(null),r=[];let s=!0
+;const o="Could not find the language '{}', did you forget to load/include a language module?",c={
+disableAutodetect:!0,name:"Plain text",contains:[]};let p={
+ignoreUnescapedHTML:!1,throwUnescapedHTML:!1,noHighlightRe:/^(no-?highlight)$/i,
+languageDetectRe:/\blang(?:uage)?-([\w-]+)\b/i,classPrefix:"hljs-",
+cssSelector:"pre code",languages:null,__emitter:l};function _(e){
+return p.noHighlightRe.test(e)}function h(e,n,t){let a="",i=""
+;"object"==typeof n?(a=e,
+t=n.ignoreIllegals,i=n.language):(q("10.7.0","highlight(lang, code, ...args) has been deprecated."),
+q("10.7.0","Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
+i=e,a=n),void 0===t&&(t=!0);const r={code:a,language:i};x("before:highlight",r)
+;const s=r.result?r.result:f(r.language,r.code,t)
+;return s.code=r.code,x("after:highlight",s),s}function f(e,t,i,r){
+const l=Object.create(null);function c(){if(!x.keywords)return void S.addText(A)
+;let e=0;x.keywordPatternRe.lastIndex=0;let n=x.keywordPatternRe.exec(A),t=""
+;for(;n;){t+=A.substring(e,n.index)
+;const i=w.case_insensitive?n[0].toLowerCase():n[0],r=(a=i,x.keywords[a]);if(r){
+const[e,a]=r
+;if(S.addText(t),t="",l[i]=(l[i]||0)+1,l[i]<=7&&(C+=a),e.startsWith("_"))t+=n[0];else{
+const t=w.classNameAliases[e]||e;g(n[0],t)}}else t+=n[0]
+;e=x.keywordPatternRe.lastIndex,n=x.keywordPatternRe.exec(A)}var a
+;t+=A.substring(e),S.addText(t)}function d(){null!=x.subLanguage?(()=>{
+if(""===A)return;let e=null;if("string"==typeof x.subLanguage){
+if(!a[x.subLanguage])return void S.addText(A)
+;e=f(x.subLanguage,A,!0,M[x.subLanguage]),M[x.subLanguage]=e._top
+}else e=E(A,x.subLanguage.length?x.subLanguage:null)
+;x.relevance>0&&(C+=e.relevance),S.__addSublanguage(e._emitter,e.language)
+})():c(),A=""}function g(e,n){
+""!==e&&(S.startScope(n),S.addText(e),S.endScope())}function u(e,n){let t=1
+;const a=n.length-1;for(;t<=a;){if(!e._emit[t]){t++;continue}
+const a=w.classNameAliases[e[t]]||e[t],i=n[t];a?g(i,a):(A=i,c(),A=""),t++}}
+function b(e,n){
+return e.scope&&"string"==typeof e.scope&&S.openNode(w.classNameAliases[e.scope]||e.scope),
+e.beginScope&&(e.beginScope._wrap?(g(A,w.classNameAliases[e.beginScope._wrap]||e.beginScope._wrap),
+A=""):e.beginScope._multi&&(u(e.beginScope,n),A="")),x=Object.create(e,{parent:{
+value:x}}),x}function m(e,t,a){let i=((e,n)=>{const t=e&&e.exec(n)
+;return t&&0===t.index})(e.endRe,a);if(i){if(e["on:end"]){const a=new n(e)
+;e["on:end"](t,a),a.isMatchIgnored&&(i=!1)}if(i){
+for(;e.endsParent&&e.parent;)e=e.parent;return e}}
+if(e.endsWithParent)return m(e.parent,t,a)}function _(e){
+return 0===x.matcher.regexIndex?(A+=e[0],1):(D=!0,0)}function h(e){
+const n=e[0],a=t.substring(e.index),i=m(x,e,a);if(!i)return ee;const r=x
+;x.endScope&&x.endScope._wrap?(d(),
+g(n,x.endScope._wrap)):x.endScope&&x.endScope._multi?(d(),
+u(x.endScope,e)):r.skip?A+=n:(r.returnEnd||r.excludeEnd||(A+=n),
+d(),r.excludeEnd&&(A=n));do{
+x.scope&&S.closeNode(),x.skip||x.subLanguage||(C+=x.relevance),x=x.parent
+}while(x!==i.parent);return i.starts&&b(i.starts,e),r.returnEnd?0:n.length}
+let y={};function N(a,r){const o=r&&r[0];if(A+=a,null==o)return d(),0
+;if("begin"===y.type&&"end"===r.type&&y.index===r.index&&""===o){
+if(A+=t.slice(r.index,r.index+1),!s){const n=Error(`0 width match regex (${e})`)
+;throw n.languageName=e,n.badRule=y.rule,n}return 1}
+if(y=r,"begin"===r.type)return(e=>{
+const t=e[0],a=e.rule,i=new n(a),r=[a.__beforeBegin,a["on:begin"]]
+;for(const n of r)if(n&&(n(e,i),i.isMatchIgnored))return _(t)
+;return a.skip?A+=t:(a.excludeBegin&&(A+=t),
+d(),a.returnBegin||a.excludeBegin||(A=t)),b(a,e),a.returnBegin?0:t.length})(r)
+;if("illegal"===r.type&&!i){
+const e=Error('Illegal lexeme "'+o+'" for mode "'+(x.scope||"<unnamed>")+'"')
+;throw e.mode=x,e}if("end"===r.type){const e=h(r);if(e!==ee)return e}
+if("illegal"===r.type&&""===o)return 1
+;if(R>1e5&&R>3*r.index)throw Error("potential infinite loop, way more iterations than matches")
+;return A+=o,o.length}const w=v(e)
+;if(!w)throw K(o.replace("{}",e)),Error('Unknown language: "'+e+'"')
+;const O=Q(w);let k="",x=r||O;const M={},S=new p.__emitter(p);(()=>{const e=[]
+;for(let n=x;n!==w;n=n.parent)n.scope&&e.unshift(n.scope)
+;e.forEach((e=>S.openNode(e)))})();let A="",C=0,T=0,R=0,D=!1;try{
+if(w.__emitTokens)w.__emitTokens(t,S);else{for(x.matcher.considerAll();;){
+R++,D?D=!1:x.matcher.considerAll(),x.matcher.lastIndex=T
+;const e=x.matcher.exec(t);if(!e)break;const n=N(t.substring(T,e.index),e)
+;T=e.index+n}N(t.substring(T))}return S.finalize(),k=S.toHTML(),{language:e,
+value:k,relevance:C,illegal:!1,_emitter:S,_top:x}}catch(n){
+if(n.message&&n.message.includes("Illegal"))return{language:e,value:J(t),
+illegal:!0,relevance:0,_illegalBy:{message:n.message,index:T,
+context:t.slice(T-100,T+100),mode:n.mode,resultSoFar:k},_emitter:S};if(s)return{
+language:e,value:J(t),illegal:!1,relevance:0,errorRaised:n,_emitter:S,_top:x}
+;throw n}}function E(e,n){n=n||p.languages||Object.keys(a);const t=(e=>{
+const n={value:J(e),illegal:!1,relevance:0,_top:c,_emitter:new p.__emitter(p)}
+;return n._emitter.addText(e),n})(e),i=n.filter(v).filter(k).map((n=>f(n,e,!1)))
+;i.unshift(t);const r=i.sort(((e,n)=>{
+if(e.relevance!==n.relevance)return n.relevance-e.relevance
+;if(e.language&&n.language){if(v(e.language).supersetOf===n.language)return 1
+;if(v(n.language).supersetOf===e.language)return-1}return 0})),[s,o]=r,l=s
+;return l.secondBest=o,l}function y(e){let n=null;const t=(e=>{
+let n=e.className+" ";n+=e.parentNode?e.parentNode.className:""
+;const t=p.languageDetectRe.exec(n);if(t){const n=v(t[1])
+;return n||(H(o.replace("{}",t[1])),
+H("Falling back to no-highlight mode for this block.",e)),n?t[1]:"no-highlight"}
+return n.split(/\s+/).find((e=>_(e)||v(e)))})(e);if(_(t))return
+;if(x("before:highlightElement",{el:e,language:t
+}),e.dataset.highlighted)return void console.log("Element previously highlighted. To highlight again, first unset `dataset.highlighted`.",e)
+;if(e.children.length>0&&(p.ignoreUnescapedHTML||(console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
+console.warn("https://github.com/highlightjs/highlight.js/wiki/security"),
+console.warn("The element with unescaped HTML:"),
+console.warn(e)),p.throwUnescapedHTML))throw new V("One of your code blocks includes unescaped HTML.",e.innerHTML)
+;n=e;const a=n.textContent,r=t?h(a,{language:t,ignoreIllegals:!0}):E(a)
+;e.innerHTML=r.value,e.dataset.highlighted="yes",((e,n,t)=>{const a=n&&i[n]||t
+;e.classList.add("hljs"),e.classList.add("language-"+a)
+})(e,t,r.language),e.result={language:r.language,re:r.relevance,
+relevance:r.relevance},r.secondBest&&(e.secondBest={
+language:r.secondBest.language,relevance:r.secondBest.relevance
+}),x("after:highlightElement",{el:e,result:r,text:a})}let N=!1;function w(){
+"loading"!==document.readyState?document.querySelectorAll(p.cssSelector).forEach(y):N=!0
+}function v(e){return e=(e||"").toLowerCase(),a[e]||a[i[e]]}
+function O(e,{languageName:n}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
+i[e.toLowerCase()]=n}))}function k(e){const n=v(e)
+;return n&&!n.disableAutodetect}function x(e,n){const t=e;r.forEach((e=>{
+e[t]&&e[t](n)}))}
+"undefined"!=typeof window&&window.addEventListener&&window.addEventListener("DOMContentLoaded",(()=>{
+N&&w()}),!1),Object.assign(t,{highlight:h,highlightAuto:E,highlightAll:w,
+highlightElement:y,
+highlightBlock:e=>(q("10.7.0","highlightBlock will be removed entirely in v12.0"),
+q("10.7.0","Please use highlightElement now."),y(e)),configure:e=>{p=Y(p,e)},
+initHighlighting:()=>{
+w(),q("10.6.0","initHighlighting() deprecated.  Use highlightAll() now.")},
+initHighlightingOnLoad:()=>{
+w(),q("10.6.0","initHighlightingOnLoad() deprecated.  Use highlightAll() now.")
+},registerLanguage:(e,n)=>{let i=null;try{i=n(t)}catch(n){
+if(K("Language definition for '{}' could not be registered.".replace("{}",e)),
+!s)throw n;K(n),i=c}
+i.name||(i.name=e),a[e]=i,i.rawDefinition=n.bind(null,t),i.aliases&&O(i.aliases,{
+languageName:e})},unregisterLanguage:e=>{delete a[e]
+;for(const n of Object.keys(i))i[n]===e&&delete i[n]},
+listLanguages:()=>Object.keys(a),getLanguage:v,registerAliases:O,
+autoDetection:k,inherit:Y,addPlugin:e=>{(e=>{
+e["before:highlightBlock"]&&!e["before:highlightElement"]&&(e["before:highlightElement"]=n=>{
+e["before:highlightBlock"](Object.assign({block:n.el},n))
+}),e["after:highlightBlock"]&&!e["after:highlightElement"]&&(e["after:highlightElement"]=n=>{
+e["after:highlightBlock"](Object.assign({block:n.el},n))})})(e),r.push(e)},
+removePlugin:e=>{const n=r.indexOf(e);-1!==n&&r.splice(n,1)}}),t.debugMode=()=>{
+s=!1},t.safeMode=()=>{s=!0},t.versionString="11.9.0",t.regex={concat:b,
+lookahead:d,either:m,optional:u,anyNumberOfTimes:g}
+;for(const n in C)"object"==typeof C[n]&&e(C[n]);return Object.assign(t,C),t
+},te=ne({});te.newInstance=()=>ne({});var ae=te;const ie=e=>({IMPORTANT:{
+scope:"meta",begin:"!important"},BLOCK_COMMENT:e.C_BLOCK_COMMENT_MODE,HEXCOLOR:{
+scope:"number",begin:/#(([0-9a-fA-F]{3,4})|(([0-9a-fA-F]{2}){3,4}))\b/},
+FUNCTION_DISPATCH:{className:"built_in",begin:/[\w-]+(?=\()/},
+ATTRIBUTE_SELECTOR_MODE:{scope:"selector-attr",begin:/\[/,end:/\]/,illegal:"$",
+contains:[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]},CSS_NUMBER_MODE:{
+scope:"number",
+begin:e.NUMBER_RE+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",
+relevance:0},CSS_VARIABLE:{className:"attr",begin:/--[A-Za-z_][A-Za-z0-9_-]*/}
+}),re=["a","abbr","address","article","aside","audio","b","blockquote","body","button","canvas","caption","cite","code","dd","del","details","dfn","div","dl","dt","em","fieldset","figcaption","figure","footer","form","h1","h2","h3","h4","h5","h6","header","hgroup","html","i","iframe","img","input","ins","kbd","label","legend","li","main","mark","menu","nav","object","ol","p","q","quote","samp","section","span","strong","summary","sup","table","tbody","td","textarea","tfoot","th","thead","time","tr","ul","var","video"],se=["any-hover","any-pointer","aspect-ratio","color","color-gamut","color-index","device-aspect-ratio","device-height","device-width","display-mode","forced-colors","grid","height","hover","inverted-colors","monochrome","orientation","overflow-block","overflow-inline","pointer","prefers-color-scheme","prefers-contrast","prefers-reduced-motion","prefers-reduced-transparency","resolution","scan","scripting","update","width","min-width","max-width","min-height","max-height"],oe=["active","any-link","blank","checked","current","default","defined","dir","disabled","drop","empty","enabled","first","first-child","first-of-type","fullscreen","future","focus","focus-visible","focus-within","has","host","host-context","hover","indeterminate","in-range","invalid","is","lang","last-child","last-of-type","left","link","local-link","not","nth-child","nth-col","nth-last-child","nth-last-col","nth-last-of-type","nth-of-type","only-child","only-of-type","optional","out-of-range","past","placeholder-shown","read-only","read-write","required","right","root","scope","target","target-within","user-invalid","valid","visited","where"],le=["after","backdrop","before","cue","cue-region","first-letter","first-line","grammar-error","marker","part","placeholder","selection","slotted","spelling-error"],ce=["align-content","align-items","align-self","all","animation","animation-delay","animation-direction","animation-duration","animation-fill-mode","animation-iteration-count","animation-name","animation-play-state","animation-timing-function","backface-visibility","background","background-attachment","background-blend-mode","background-clip","background-color","background-image","background-origin","background-position","background-repeat","background-size","block-size","border","border-block","border-block-color","border-block-end","border-block-end-color","border-block-end-style","border-block-end-width","border-block-start","border-block-start-color","border-block-start-style","border-block-start-width","border-block-style","border-block-width","border-bottom","border-bottom-color","border-bottom-left-radius","border-bottom-right-radius","border-bottom-style","border-bottom-width","border-collapse","border-color","border-image","border-image-outset","border-image-repeat","border-image-slice","border-image-source","border-image-width","border-inline","border-inline-color","border-inline-end","border-inline-end-color","border-inline-end-style","border-inline-end-width","border-inline-start","border-inline-start-color","border-inline-start-style","border-inline-start-width","border-inline-style","border-inline-width","border-left","border-left-color","border-left-style","border-left-width","border-radius","border-right","border-right-color","border-right-style","border-right-width","border-spacing","border-style","border-top","border-top-color","border-top-left-radius","border-top-right-radius","border-top-style","border-top-width","border-width","bottom","box-decoration-break","box-shadow","box-sizing","break-after","break-before","break-inside","caption-side","caret-color","clear","clip","clip-path","clip-rule","color","column-count","column-fill","column-gap","column-rule","column-rule-color","column-rule-style","column-rule-width","column-span","column-width","columns","contain","content","content-visibility","counter-increment","counter-reset","cue","cue-after","cue-before","cursor","direction","display","empty-cells","filter","flex","flex-basis","flex-direction","flex-flow","flex-grow","flex-shrink","flex-wrap","float","flow","font","font-display","font-family","font-feature-settings","font-kerning","font-language-override","font-size","font-size-adjust","font-smoothing","font-stretch","font-style","font-synthesis","font-variant","font-variant-caps","font-variant-east-asian","font-variant-ligatures","font-variant-numeric","font-variant-position","font-variation-settings","font-weight","gap","glyph-orientation-vertical","grid","grid-area","grid-auto-columns","grid-auto-flow","grid-auto-rows","grid-column","grid-column-end","grid-column-start","grid-gap","grid-row","grid-row-end","grid-row-start","grid-template","grid-template-areas","grid-template-columns","grid-template-rows","hanging-punctuation","height","hyphens","icon","image-orientation","image-rendering","image-resolution","ime-mode","inline-size","isolation","justify-content","left","letter-spacing","line-break","line-height","list-style","list-style-image","list-style-position","list-style-type","margin","margin-block","margin-block-end","margin-block-start","margin-bottom","margin-inline","margin-inline-end","margin-inline-start","margin-left","margin-right","margin-top","marks","mask","mask-border","mask-border-mode","mask-border-outset","mask-border-repeat","mask-border-slice","mask-border-source","mask-border-width","mask-clip","mask-composite","mask-image","mask-mode","mask-origin","mask-position","mask-repeat","mask-size","mask-type","max-block-size","max-height","max-inline-size","max-width","min-block-size","min-height","min-inline-size","min-width","mix-blend-mode","nav-down","nav-index","nav-left","nav-right","nav-up","none","normal","object-fit","object-position","opacity","order","orphans","outline","outline-color","outline-offset","outline-style","outline-width","overflow","overflow-wrap","overflow-x","overflow-y","padding","padding-block","padding-block-end","padding-block-start","padding-bottom","padding-inline","padding-inline-end","padding-inline-start","padding-left","padding-right","padding-top","page-break-after","page-break-before","page-break-inside","pause","pause-after","pause-before","perspective","perspective-origin","pointer-events","position","quotes","resize","rest","rest-after","rest-before","right","row-gap","scroll-margin","scroll-margin-block","scroll-margin-block-end","scroll-margin-block-start","scroll-margin-bottom","scroll-margin-inline","scroll-margin-inline-end","scroll-margin-inline-start","scroll-margin-left","scroll-margin-right","scroll-margin-top","scroll-padding","scroll-padding-block","scroll-padding-block-end","scroll-padding-block-start","scroll-padding-bottom","scroll-padding-inline","scroll-padding-inline-end","scroll-padding-inline-start","scroll-padding-left","scroll-padding-right","scroll-padding-top","scroll-snap-align","scroll-snap-stop","scroll-snap-type","scrollbar-color","scrollbar-gutter","scrollbar-width","shape-image-threshold","shape-margin","shape-outside","speak","speak-as","src","tab-size","table-layout","text-align","text-align-all","text-align-last","text-combine-upright","text-decoration","text-decoration-color","text-decoration-line","text-decoration-style","text-emphasis","text-emphasis-color","text-emphasis-position","text-emphasis-style","text-indent","text-justify","text-orientation","text-overflow","text-rendering","text-shadow","text-transform","text-underline-position","top","transform","transform-box","transform-origin","transform-style","transition","transition-delay","transition-duration","transition-property","transition-timing-function","unicode-bidi","vertical-align","visibility","voice-balance","voice-duration","voice-family","voice-pitch","voice-range","voice-rate","voice-stress","voice-volume","white-space","widows","width","will-change","word-break","word-spacing","word-wrap","writing-mode","z-index"].reverse(),de=oe.concat(le)
+;var ge="[0-9](_*[0-9])*",ue=`\\.(${ge})`,be="[0-9a-fA-F](_*[0-9a-fA-F])*",me={
+className:"number",variants:[{
+begin:`(\\b(${ge})((${ue})|\\.)?|(${ue}))[eE][+-]?(${ge})[fFdD]?\\b`},{
+begin:`\\b(${ge})((${ue})[fFdD]?\\b|\\.([fFdD]\\b)?)`},{
+begin:`(${ue})[fFdD]?\\b`},{begin:`\\b(${ge})[fFdD]\\b`},{
+begin:`\\b0[xX]((${be})\\.?|(${be})?\\.(${be}))[pP][+-]?(${ge})[fFdD]?\\b`},{
+begin:"\\b(0|[1-9](_*[0-9])*)[lL]?\\b"},{begin:`\\b0[xX](${be})[lL]?\\b`},{
+begin:"\\b0(_*[0-7])*[lL]?\\b"},{begin:"\\b0[bB][01](_*[01])*[lL]?\\b"}],
+relevance:0};function pe(e,n,t){return-1===t?"":e.replace(n,(a=>pe(e,n,t-1)))}
+const _e="[A-Za-z$_][0-9A-Za-z$_]*",he=["as","in","of","if","for","while","finally","var","new","function","do","return","void","else","break","catch","instanceof","with","throw","case","default","try","switch","continue","typeof","delete","let","yield","const","class","debugger","async","await","static","import","from","export","extends"],fe=["true","false","null","undefined","NaN","Infinity"],Ee=["Object","Function","Boolean","Symbol","Math","Date","Number","BigInt","String","RegExp","Array","Float32Array","Float64Array","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Int32Array","Uint16Array","Uint32Array","BigInt64Array","BigUint64Array","Set","Map","WeakSet","WeakMap","ArrayBuffer","SharedArrayBuffer","Atomics","DataView","JSON","Promise","Generator","GeneratorFunction","AsyncFunction","Reflect","Proxy","Intl","WebAssembly"],ye=["Error","EvalError","InternalError","RangeError","ReferenceError","SyntaxError","TypeError","URIError"],Ne=["setInterval","setTimeout","clearInterval","clearTimeout","require","exports","eval","isFinite","isNaN","parseFloat","parseInt","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","escape","unescape"],we=["arguments","this","super","console","window","document","localStorage","sessionStorage","module","global"],ve=[].concat(Ne,Ee,ye)
+;function Oe(e){const n=e.regex,t=_e,a={begin:/<[A-Za-z0-9\\._:-]+/,
+end:/\/[A-Za-z0-9\\._:-]+>|\/>/,isTrulyOpeningTag:(e,n)=>{
+const t=e[0].length+e.index,a=e.input[t]
+;if("<"===a||","===a)return void n.ignoreMatch();let i
+;">"===a&&(((e,{after:n})=>{const t="</"+e[0].slice(1)
+;return-1!==e.input.indexOf(t,n)})(e,{after:t})||n.ignoreMatch())
+;const r=e.input.substring(t)
+;((i=r.match(/^\s*=/))||(i=r.match(/^\s+extends\s+/))&&0===i.index)&&n.ignoreMatch()
+}},i={$pattern:_e,keyword:he,literal:fe,built_in:ve,"variable.language":we
+},r="[0-9](_?[0-9])*",s=`\\.(${r})`,o="0|[1-9](_?[0-9])*|0[0-7]*[89][0-9]*",l={
+className:"number",variants:[{
+begin:`(\\b(${o})((${s})|\\.)?|(${s}))[eE][+-]?(${r})\\b`},{
+begin:`\\b(${o})\\b((${s})\\b|\\.)?|(${s})\\b`},{
+begin:"\\b(0|[1-9](_?[0-9])*)n\\b"},{
+begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*n?\\b"},{
+begin:"\\b0[bB][0-1](_?[0-1])*n?\\b"},{begin:"\\b0[oO][0-7](_?[0-7])*n?\\b"},{
+begin:"\\b0[0-7]+n?\\b"}],relevance:0},c={className:"subst",begin:"\\$\\{",
+end:"\\}",keywords:i,contains:[]},d={begin:"html`",end:"",starts:{end:"`",
+returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,c],subLanguage:"xml"}},g={
+begin:"css`",end:"",starts:{end:"`",returnEnd:!1,
+contains:[e.BACKSLASH_ESCAPE,c],subLanguage:"css"}},u={begin:"gql`",end:"",
+starts:{end:"`",returnEnd:!1,contains:[e.BACKSLASH_ESCAPE,c],
+subLanguage:"graphql"}},b={className:"string",begin:"`",end:"`",
+contains:[e.BACKSLASH_ESCAPE,c]},m={className:"comment",
+variants:[e.COMMENT(/\/\*\*(?!\/)/,"\\*/",{relevance:0,contains:[{
+begin:"(?=@[A-Za-z]+)",relevance:0,contains:[{className:"doctag",
+begin:"@[A-Za-z]+"},{className:"type",begin:"\\{",end:"\\}",excludeEnd:!0,
+excludeBegin:!0,relevance:0},{className:"variable",begin:t+"(?=\\s*(-)|$)",
+endsParent:!0,relevance:0},{begin:/(?=[^\n])\s/,relevance:0}]}]
+}),e.C_BLOCK_COMMENT_MODE,e.C_LINE_COMMENT_MODE]
+},p=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,d,g,u,b,{match:/\$\d+/},l]
+;c.contains=p.concat({begin:/\{/,end:/\}/,keywords:i,contains:["self"].concat(p)
+});const _=[].concat(m,c.contains),h=_.concat([{begin:/\(/,end:/\)/,keywords:i,
+contains:["self"].concat(_)}]),f={className:"params",begin:/\(/,end:/\)/,
+excludeBegin:!0,excludeEnd:!0,keywords:i,contains:h},E={variants:[{
+match:[/class/,/\s+/,t,/\s+/,/extends/,/\s+/,n.concat(t,"(",n.concat(/\./,t),")*")],
+scope:{1:"keyword",3:"title.class",5:"keyword",7:"title.class.inherited"}},{
+match:[/class/,/\s+/,t],scope:{1:"keyword",3:"title.class"}}]},y={relevance:0,
+match:n.either(/\bJSON/,/\b[A-Z][a-z]+([A-Z][a-z]*|\d)*/,/\b[A-Z]{2,}([A-Z][a-z]+|\d)+([A-Z][a-z]*)*/,/\b[A-Z]{2,}[a-z]+([A-Z][a-z]+|\d)*([A-Z][a-z]*)*/),
+className:"title.class",keywords:{_:[...Ee,...ye]}},N={variants:[{
+match:[/function/,/\s+/,t,/(?=\s*\()/]},{match:[/function/,/\s*(?=\()/]}],
+className:{1:"keyword",3:"title.function"},label:"func.def",contains:[f],
+illegal:/%/},w={
+match:n.concat(/\b/,(v=[...Ne,"super","import"],n.concat("(?!",v.join("|"),")")),t,n.lookahead(/\(/)),
+className:"title.function",relevance:0};var v;const O={
+begin:n.concat(/\./,n.lookahead(n.concat(t,/(?![0-9A-Za-z$_(])/))),end:t,
+excludeBegin:!0,keywords:"prototype",className:"property",relevance:0},k={
+match:[/get|set/,/\s+/,t,/(?=\()/],className:{1:"keyword",3:"title.function"},
+contains:[{begin:/\(\)/},f]
+},x="(\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)|"+e.UNDERSCORE_IDENT_RE+")\\s*=>",M={
+match:[/const|var|let/,/\s+/,t,/\s*/,/=\s*/,/(async\s*)?/,n.lookahead(x)],
+keywords:"async",className:{1:"keyword",3:"title.function"},contains:[f]}
+;return{name:"JavaScript",aliases:["js","jsx","mjs","cjs"],keywords:i,exports:{
+PARAMS_CONTAINS:h,CLASS_REFERENCE:y},illegal:/#(?![$_A-z])/,
+contains:[e.SHEBANG({label:"shebang",binary:"node",relevance:5}),{
+label:"use_strict",className:"meta",relevance:10,
+begin:/^\s*['"]use (strict|asm)['"]/
+},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,d,g,u,b,m,{match:/\$\d+/},l,y,{
+className:"attr",begin:t+n.lookahead(":"),relevance:0},M,{
+begin:"("+e.RE_STARTERS_RE+"|\\b(case|return|throw)\\b)\\s*",
+keywords:"return throw case",relevance:0,contains:[m,e.REGEXP_MODE,{
+className:"function",begin:x,returnBegin:!0,end:"\\s*=>",contains:[{
+className:"params",variants:[{begin:e.UNDERSCORE_IDENT_RE,relevance:0},{
+className:null,begin:/\(\s*\)/,skip:!0},{begin:/\(/,end:/\)/,excludeBegin:!0,
+excludeEnd:!0,keywords:i,contains:h}]}]},{begin:/,/,relevance:0},{match:/\s+/,
+relevance:0},{variants:[{begin:"<>",end:"</>"},{
+match:/<[A-Za-z0-9\\._:-]+\s*\/>/},{begin:a.begin,
+"on:begin":a.isTrulyOpeningTag,end:a.end}],subLanguage:"xml",contains:[{
+begin:a.begin,end:a.end,skip:!0,contains:["self"]}]}]},N,{
+beginKeywords:"while if switch catch for"},{
+begin:"\\b(?!function)"+e.UNDERSCORE_IDENT_RE+"\\([^()]*(\\([^()]*(\\([^()]*\\)[^()]*)*\\)[^()]*)*\\)\\s*\\{",
+returnBegin:!0,label:"func.def",contains:[f,e.inherit(e.TITLE_MODE,{begin:t,
+className:"title.function"})]},{match:/\.\.\./,relevance:0},O,{match:"\\$"+t,
+relevance:0},{match:[/\bconstructor(?=\s*\()/],className:{1:"title.function"},
+contains:[f]},w,{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,
+className:"variable.constant"},E,k,{match:/\$[(.]/}]}}
+const ke=e=>b(/\b/,e,/\w$/.test(e)?/\b/:/\B/),xe=["Protocol","Type"].map(ke),Me=["init","self"].map(ke),Se=["Any","Self"],Ae=["actor","any","associatedtype","async","await",/as\?/,/as!/,"as","borrowing","break","case","catch","class","consume","consuming","continue","convenience","copy","default","defer","deinit","didSet","distributed","do","dynamic","each","else","enum","extension","fallthrough",/fileprivate\(set\)/,"fileprivate","final","for","func","get","guard","if","import","indirect","infix",/init\?/,/init!/,"inout",/internal\(set\)/,"internal","in","is","isolated","nonisolated","lazy","let","macro","mutating","nonmutating",/open\(set\)/,"open","operator","optional","override","postfix","precedencegroup","prefix",/private\(set\)/,"private","protocol",/public\(set\)/,"public","repeat","required","rethrows","return","set","some","static","struct","subscript","super","switch","throws","throw",/try\?/,/try!/,"try","typealias",/unowned\(safe\)/,/unowned\(unsafe\)/,"unowned","var","weak","where","while","willSet"],Ce=["false","nil","true"],Te=["assignment","associativity","higherThan","left","lowerThan","none","right"],Re=["#colorLiteral","#column","#dsohandle","#else","#elseif","#endif","#error","#file","#fileID","#fileLiteral","#filePath","#function","#if","#imageLiteral","#keyPath","#line","#selector","#sourceLocation","#warning"],De=["abs","all","any","assert","assertionFailure","debugPrint","dump","fatalError","getVaList","isKnownUniquelyReferenced","max","min","numericCast","pointwiseMax","pointwiseMin","precondition","preconditionFailure","print","readLine","repeatElement","sequence","stride","swap","swift_unboxFromSwiftValueWithType","transcode","type","unsafeBitCast","unsafeDowncast","withExtendedLifetime","withUnsafeMutablePointer","withUnsafePointer","withVaList","withoutActuallyEscaping","zip"],Ie=m(/[/=\-+!*%<>&|^~?]/,/[\u00A1-\u00A7]/,/[\u00A9\u00AB]/,/[\u00AC\u00AE]/,/[\u00B0\u00B1]/,/[\u00B6\u00BB\u00BF\u00D7\u00F7]/,/[\u2016-\u2017]/,/[\u2020-\u2027]/,/[\u2030-\u203E]/,/[\u2041-\u2053]/,/[\u2055-\u205E]/,/[\u2190-\u23FF]/,/[\u2500-\u2775]/,/[\u2794-\u2BFF]/,/[\u2E00-\u2E7F]/,/[\u3001-\u3003]/,/[\u3008-\u3020]/,/[\u3030]/),Le=m(Ie,/[\u0300-\u036F]/,/[\u1DC0-\u1DFF]/,/[\u20D0-\u20FF]/,/[\uFE00-\uFE0F]/,/[\uFE20-\uFE2F]/),Be=b(Ie,Le,"*"),$e=m(/[a-zA-Z_]/,/[\u00A8\u00AA\u00AD\u00AF\u00B2-\u00B5\u00B7-\u00BA]/,/[\u00BC-\u00BE\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF]/,/[\u0100-\u02FF\u0370-\u167F\u1681-\u180D\u180F-\u1DBF]/,/[\u1E00-\u1FFF]/,/[\u200B-\u200D\u202A-\u202E\u203F-\u2040\u2054\u2060-\u206F]/,/[\u2070-\u20CF\u2100-\u218F\u2460-\u24FF\u2776-\u2793]/,/[\u2C00-\u2DFF\u2E80-\u2FFF]/,/[\u3004-\u3007\u3021-\u302F\u3031-\u303F\u3040-\uD7FF]/,/[\uF900-\uFD3D\uFD40-\uFDCF\uFDF0-\uFE1F\uFE30-\uFE44]/,/[\uFE47-\uFEFE\uFF00-\uFFFD]/),ze=m($e,/\d/,/[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE20-\uFE2F]/),Fe=b($e,ze,"*"),Ue=b(/[A-Z]/,ze,"*"),je=["attached","autoclosure",b(/convention\(/,m("swift","block","c"),/\)/),"discardableResult","dynamicCallable","dynamicMemberLookup","escaping","freestanding","frozen","GKInspectable","IBAction","IBDesignable","IBInspectable","IBOutlet","IBSegueAction","inlinable","main","nonobjc","NSApplicationMain","NSCopying","NSManaged",b(/objc\(/,Fe,/\)/),"objc","objcMembers","propertyWrapper","requires_stored_property_inits","resultBuilder","Sendable","testable","UIApplicationMain","unchecked","unknown","usableFromInline","warn_unqualified_access"],Pe=["iOS","iOSApplicationExtension","macOS","macOSApplicationExtension","macCatalyst","macCatalystApplicationExtension","watchOS","watchOSApplicationExtension","tvOS","tvOSApplicationExtension","swift"]
+;var Ke=Object.freeze({__proto__:null,grmr_bash:e=>{const n=e.regex,t={},a={
+begin:/\$\{/,end:/\}/,contains:["self",{begin:/:-/,contains:[t]}]}
+;Object.assign(t,{className:"variable",variants:[{
+begin:n.concat(/\$[\w\d#@][\w\d_]*/,"(?![\\w\\d])(?![$])")},a]});const i={
+className:"subst",begin:/\$\(/,end:/\)/,contains:[e.BACKSLASH_ESCAPE]},r={
+begin:/<<-?\s*(?=\w+)/,starts:{contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,
+end:/(\w+)/,className:"string"})]}},s={className:"string",begin:/"/,end:/"/,
+contains:[e.BACKSLASH_ESCAPE,t,i]};i.contains.push(s);const o={begin:/\$?\(\(/,
+end:/\)\)/,contains:[{begin:/\d+#[0-9a-f]+/,className:"number"},e.NUMBER_MODE,t]
+},l=e.SHEBANG({binary:"(fish|bash|zsh|sh|csh|ksh|tcsh|dash|scsh)",relevance:10
+}),c={className:"function",begin:/\w[\w\d_]*\s*\(\s*\)\s*\{/,returnBegin:!0,
+contains:[e.inherit(e.TITLE_MODE,{begin:/\w[\w\d_]*/})],relevance:0};return{
+name:"Bash",aliases:["sh"],keywords:{$pattern:/\b[a-z][a-z0-9._-]+\b/,
+keyword:["if","then","else","elif","fi","for","while","until","in","do","done","case","esac","function","select"],
+literal:["true","false"],
+built_in:["break","cd","continue","eval","exec","exit","export","getopts","hash","pwd","readonly","return","shift","test","times","trap","umask","unset","alias","bind","builtin","caller","command","declare","echo","enable","help","let","local","logout","mapfile","printf","read","readarray","source","type","typeset","ulimit","unalias","set","shopt","autoload","bg","bindkey","bye","cap","chdir","clone","comparguments","compcall","compctl","compdescribe","compfiles","compgroups","compquote","comptags","comptry","compvalues","dirs","disable","disown","echotc","echoti","emulate","fc","fg","float","functions","getcap","getln","history","integer","jobs","kill","limit","log","noglob","popd","print","pushd","pushln","rehash","sched","setcap","setopt","stat","suspend","ttyctl","unfunction","unhash","unlimit","unsetopt","vared","wait","whence","where","which","zcompile","zformat","zftp","zle","zmodload","zparseopts","zprof","zpty","zregexparse","zsocket","zstyle","ztcp","chcon","chgrp","chown","chmod","cp","dd","df","dir","dircolors","ln","ls","mkdir","mkfifo","mknod","mktemp","mv","realpath","rm","rmdir","shred","sync","touch","truncate","vdir","b2sum","base32","base64","cat","cksum","comm","csplit","cut","expand","fmt","fold","head","join","md5sum","nl","numfmt","od","paste","ptx","pr","sha1sum","sha224sum","sha256sum","sha384sum","sha512sum","shuf","sort","split","sum","tac","tail","tr","tsort","unexpand","uniq","wc","arch","basename","chroot","date","dirname","du","echo","env","expr","factor","groups","hostid","id","link","logname","nice","nohup","nproc","pathchk","pinky","printenv","printf","pwd","readlink","runcon","seq","sleep","stat","stdbuf","stty","tee","test","timeout","tty","uname","unlink","uptime","users","who","whoami","yes"]
+},contains:[l,e.SHEBANG(),c,o,e.HASH_COMMENT_MODE,r,{match:/(\/[a-z._-]+)+/},s,{
+match:/\\"/},{className:"string",begin:/'/,end:/'/},{match:/\\'/},t]}},
+grmr_c:e=>{const n=e.regex,t=e.COMMENT("//","$",{contains:[{begin:/\\\n/}]
+}),a="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",r="("+a+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",s={
+className:"type",variants:[{begin:"\\b[a-z\\d_]*_t\\b"},{
+match:/\batomic_[a-z]{3,6}\b/}]},o={className:"string",variants:[{
+begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{
+begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
+end:"'",illegal:"."},e.END_SAME_AS_BEGIN({
+begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},l={
+className:"number",variants:[{begin:"\\b(0b[01']+)"},{
+begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"
+},{
+begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
+}],relevance:0},c={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{
+keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"
+},contains:[{begin:/\\\n/,relevance:0},e.inherit(o,{className:"string"}),{
+className:"string",begin:/<.*?>/},t,e.C_BLOCK_COMMENT_MODE]},d={
+className:"title",begin:n.optional(i)+e.IDENT_RE,relevance:0
+},g=n.optional(i)+e.IDENT_RE+"\\s*\\(",u={
+keyword:["asm","auto","break","case","continue","default","do","else","enum","extern","for","fortran","goto","if","inline","register","restrict","return","sizeof","struct","switch","typedef","union","volatile","while","_Alignas","_Alignof","_Atomic","_Generic","_Noreturn","_Static_assert","_Thread_local","alignas","alignof","noreturn","static_assert","thread_local","_Pragma"],
+type:["float","double","signed","unsigned","int","short","long","char","void","_Bool","_Complex","_Imaginary","_Decimal32","_Decimal64","_Decimal128","const","static","complex","bool","imaginary"],
+literal:"true false NULL",
+built_in:"std string wstring cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set pair bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap priority_queue make_pair array shared_ptr abort terminate abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf future isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr"
+},b=[c,s,t,e.C_BLOCK_COMMENT_MODE,l,o],m={variants:[{begin:/=/,end:/;/},{
+begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],
+keywords:u,contains:b.concat([{begin:/\(/,end:/\)/,keywords:u,
+contains:b.concat(["self"]),relevance:0}]),relevance:0},p={
+begin:"("+r+"[\\*&\\s]+)+"+g,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,
+keywords:u,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:a,keywords:u,relevance:0},{
+begin:g,returnBegin:!0,contains:[e.inherit(d,{className:"title.function"})],
+relevance:0},{relevance:0,match:/,/},{className:"params",begin:/\(/,end:/\)/,
+keywords:u,relevance:0,contains:[t,e.C_BLOCK_COMMENT_MODE,o,l,s,{begin:/\(/,
+end:/\)/,keywords:u,relevance:0,contains:["self",t,e.C_BLOCK_COMMENT_MODE,o,l,s]
+}]},s,t,e.C_BLOCK_COMMENT_MODE,c]};return{name:"C",aliases:["h"],keywords:u,
+disableAutodetect:!0,illegal:"</",contains:[].concat(m,p,b,[c,{
+begin:e.IDENT_RE+"::",keywords:u},{className:"class",
+beginKeywords:"enum class struct union",end:/[{;:<>=]/,contains:[{
+beginKeywords:"final class struct"},e.TITLE_MODE]}]),exports:{preprocessor:c,
+strings:o,keywords:u}}},grmr_cpp:e=>{const n=e.regex,t=e.COMMENT("//","$",{
+contains:[{begin:/\\\n/}]
+}),a="decltype\\(auto\\)",i="[a-zA-Z_]\\w*::",r="(?!struct)("+a+"|"+n.optional(i)+"[a-zA-Z_]\\w*"+n.optional("<[^<>]+>")+")",s={
+className:"type",begin:"\\b[a-z\\d_]*_t\\b"},o={className:"string",variants:[{
+begin:'(u8?|U|L)?"',end:'"',illegal:"\\n",contains:[e.BACKSLASH_ESCAPE]},{
+begin:"(u8?|U|L)?'(\\\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4,8}|[0-7]{3}|\\S)|.)",
+end:"'",illegal:"."},e.END_SAME_AS_BEGIN({
+begin:/(?:u8?|U|L)?R"([^()\\ ]{0,16})\(/,end:/\)([^()\\ ]{0,16})"/})]},l={
+className:"number",variants:[{begin:"\\b(0b[01']+)"},{
+begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)((ll|LL|l|L)(u|U)?|(u|U)(ll|LL|l|L)?|f|F|b|B)"
+},{
+begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
+}],relevance:0},c={className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,keywords:{
+keyword:"if else elif endif define undef warning error line pragma _Pragma ifdef ifndef include"
+},contains:[{begin:/\\\n/,relevance:0},e.inherit(o,{className:"string"}),{
+className:"string",begin:/<.*?>/},t,e.C_BLOCK_COMMENT_MODE]},d={
+className:"title",begin:n.optional(i)+e.IDENT_RE,relevance:0
+},g=n.optional(i)+e.IDENT_RE+"\\s*\\(",u={
+type:["bool","char","char16_t","char32_t","char8_t","double","float","int","long","short","void","wchar_t","unsigned","signed","const","static"],
+keyword:["alignas","alignof","and","and_eq","asm","atomic_cancel","atomic_commit","atomic_noexcept","auto","bitand","bitor","break","case","catch","class","co_await","co_return","co_yield","compl","concept","const_cast|10","consteval","constexpr","constinit","continue","decltype","default","delete","do","dynamic_cast|10","else","enum","explicit","export","extern","false","final","for","friend","goto","if","import","inline","module","mutable","namespace","new","noexcept","not","not_eq","nullptr","operator","or","or_eq","override","private","protected","public","reflexpr","register","reinterpret_cast|10","requires","return","sizeof","static_assert","static_cast|10","struct","switch","synchronized","template","this","thread_local","throw","transaction_safe","transaction_safe_dynamic","true","try","typedef","typeid","typename","union","using","virtual","volatile","while","xor","xor_eq"],
+literal:["NULL","false","nullopt","nullptr","true"],built_in:["_Pragma"],
+_type_hints:["any","auto_ptr","barrier","binary_semaphore","bitset","complex","condition_variable","condition_variable_any","counting_semaphore","deque","false_type","future","imaginary","initializer_list","istringstream","jthread","latch","lock_guard","multimap","multiset","mutex","optional","ostringstream","packaged_task","pair","promise","priority_queue","queue","recursive_mutex","recursive_timed_mutex","scoped_lock","set","shared_future","shared_lock","shared_mutex","shared_timed_mutex","shared_ptr","stack","string_view","stringstream","timed_mutex","thread","true_type","tuple","unique_lock","unique_ptr","unordered_map","unordered_multimap","unordered_multiset","unordered_set","variant","vector","weak_ptr","wstring","wstring_view"]
+},b={className:"function.dispatch",relevance:0,keywords:{
+_hint:["abort","abs","acos","apply","as_const","asin","atan","atan2","calloc","ceil","cerr","cin","clog","cos","cosh","cout","declval","endl","exchange","exit","exp","fabs","floor","fmod","forward","fprintf","fputs","free","frexp","fscanf","future","invoke","isalnum","isalpha","iscntrl","isdigit","isgraph","islower","isprint","ispunct","isspace","isupper","isxdigit","labs","launder","ldexp","log","log10","make_pair","make_shared","make_shared_for_overwrite","make_tuple","make_unique","malloc","memchr","memcmp","memcpy","memset","modf","move","pow","printf","putchar","puts","realloc","scanf","sin","sinh","snprintf","sprintf","sqrt","sscanf","std","stderr","stdin","stdout","strcat","strchr","strcmp","strcpy","strcspn","strlen","strncat","strncmp","strncpy","strpbrk","strrchr","strspn","strstr","swap","tan","tanh","terminate","to_underlying","tolower","toupper","vfprintf","visit","vprintf","vsprintf"]
+},
+begin:n.concat(/\b/,/(?!decltype)/,/(?!if)/,/(?!for)/,/(?!switch)/,/(?!while)/,e.IDENT_RE,n.lookahead(/(<[^<>]+>|)\s*\(/))
+},m=[b,c,s,t,e.C_BLOCK_COMMENT_MODE,l,o],p={variants:[{begin:/=/,end:/;/},{
+begin:/\(/,end:/\)/},{beginKeywords:"new throw return else",end:/;/}],
+keywords:u,contains:m.concat([{begin:/\(/,end:/\)/,keywords:u,
+contains:m.concat(["self"]),relevance:0}]),relevance:0},_={className:"function",
+begin:"("+r+"[\\*&\\s]+)+"+g,returnBegin:!0,end:/[{;=]/,excludeEnd:!0,
+keywords:u,illegal:/[^\w\s\*&:<>.]/,contains:[{begin:a,keywords:u,relevance:0},{
+begin:g,returnBegin:!0,contains:[d],relevance:0},{begin:/::/,relevance:0},{
+begin:/:/,endsWithParent:!0,contains:[o,l]},{relevance:0,match:/,/},{
+className:"params",begin:/\(/,end:/\)/,keywords:u,relevance:0,
+contains:[t,e.C_BLOCK_COMMENT_MODE,o,l,s,{begin:/\(/,end:/\)/,keywords:u,
+relevance:0,contains:["self",t,e.C_BLOCK_COMMENT_MODE,o,l,s]}]
+},s,t,e.C_BLOCK_COMMENT_MODE,c]};return{name:"C++",
+aliases:["cc","c++","h++","hpp","hh","hxx","cxx"],keywords:u,illegal:"</",
+classNameAliases:{"function.dispatch":"built_in"},
+contains:[].concat(p,_,b,m,[c,{
+begin:"\\b(deque|list|queue|priority_queue|pair|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array|tuple|optional|variant|function)\\s*<(?!<)",
+end:">",keywords:u,contains:["self",s]},{begin:e.IDENT_RE+"::",keywords:u},{
+match:[/\b(?:enum(?:\s+(?:class|struct))?|class|struct|union)/,/\s+/,/\w+/],
+className:{1:"keyword",3:"title.class"}}])}},grmr_csharp:e=>{const n={
+keyword:["abstract","as","base","break","case","catch","class","const","continue","do","else","event","explicit","extern","finally","fixed","for","foreach","goto","if","implicit","in","interface","internal","is","lock","namespace","new","operator","out","override","params","private","protected","public","readonly","record","ref","return","scoped","sealed","sizeof","stackalloc","static","struct","switch","this","throw","try","typeof","unchecked","unsafe","using","virtual","void","volatile","while"].concat(["add","alias","and","ascending","async","await","by","descending","equals","from","get","global","group","init","into","join","let","nameof","not","notnull","on","or","orderby","partial","remove","select","set","unmanaged","value|0","var","when","where","with","yield"]),
+built_in:["bool","byte","char","decimal","delegate","double","dynamic","enum","float","int","long","nint","nuint","object","sbyte","short","string","ulong","uint","ushort"],
+literal:["default","false","null","true"]},t=e.inherit(e.TITLE_MODE,{
+begin:"[a-zA-Z](\\.?\\w)*"}),a={className:"number",variants:[{
+begin:"\\b(0b[01']+)"},{
+begin:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{
+begin:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
+}],relevance:0},i={className:"string",begin:'@"',end:'"',contains:[{begin:'""'}]
+},r=e.inherit(i,{illegal:/\n/}),s={className:"subst",begin:/\{/,end:/\}/,
+keywords:n},o=e.inherit(s,{illegal:/\n/}),l={className:"string",begin:/\$"/,
+end:'"',illegal:/\n/,contains:[{begin:/\{\{/},{begin:/\}\}/
+},e.BACKSLASH_ESCAPE,o]},c={className:"string",begin:/\$@"/,end:'"',contains:[{
+begin:/\{\{/},{begin:/\}\}/},{begin:'""'},s]},d=e.inherit(c,{illegal:/\n/,
+contains:[{begin:/\{\{/},{begin:/\}\}/},{begin:'""'},o]})
+;s.contains=[c,l,i,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.C_BLOCK_COMMENT_MODE],
+o.contains=[d,l,r,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,a,e.inherit(e.C_BLOCK_COMMENT_MODE,{
+illegal:/\n/})];const g={variants:[c,l,i,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]
+},u={begin:"<",end:">",contains:[{beginKeywords:"in out"},t]
+},b=e.IDENT_RE+"(<"+e.IDENT_RE+"(\\s*,\\s*"+e.IDENT_RE+")*>)?(\\[\\])?",m={
+begin:"@"+e.IDENT_RE,relevance:0};return{name:"C#",aliases:["cs","c#"],
+keywords:n,illegal:/::/,contains:[e.COMMENT("///","$",{returnBegin:!0,
+contains:[{className:"doctag",variants:[{begin:"///",relevance:0},{
+begin:"\x3c!--|--\x3e"},{begin:"</?",end:">"}]}]
+}),e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"meta",begin:"#",
+end:"$",keywords:{
+keyword:"if else elif endif define undef warning error line region endregion pragma checksum"
+}},g,a,{beginKeywords:"class interface",relevance:0,end:/[{;=]/,
+illegal:/[^\s:,]/,contains:[{beginKeywords:"where class"
+},t,u,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{beginKeywords:"namespace",
+relevance:0,end:/[{;=]/,illegal:/[^\s:]/,
+contains:[t,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{
+beginKeywords:"record",relevance:0,end:/[{;=]/,illegal:/[^\s:]/,
+contains:[t,u,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"meta",
+begin:"^\\s*\\[(?=[\\w])",excludeBegin:!0,end:"\\]",excludeEnd:!0,contains:[{
+className:"string",begin:/"/,end:/"/}]},{
+beginKeywords:"new return throw await else",relevance:0},{className:"function",
+begin:"("+b+"\\s+)+"+e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,
+end:/\s*[{;=]/,excludeEnd:!0,keywords:n,contains:[{
+beginKeywords:"public private protected static internal protected abstract async extern override unsafe virtual new sealed partial",
+relevance:0},{begin:e.IDENT_RE+"\\s*(<[^=]+>\\s*)?\\(",returnBegin:!0,
+contains:[e.TITLE_MODE,u],relevance:0},{match:/\(\)/},{className:"params",
+begin:/\(/,end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:n,relevance:0,
+contains:[g,a,e.C_BLOCK_COMMENT_MODE]
+},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},m]}},grmr_css:e=>{
+const n=e.regex,t=ie(e),a=[e.APOS_STRING_MODE,e.QUOTE_STRING_MODE];return{
+name:"CSS",case_insensitive:!0,illegal:/[=|'\$]/,keywords:{
+keyframePosition:"from to"},classNameAliases:{keyframePosition:"selector-tag"},
+contains:[t.BLOCK_COMMENT,{begin:/-(webkit|moz|ms|o)-(?=[a-z])/
+},t.CSS_NUMBER_MODE,{className:"selector-id",begin:/#[A-Za-z0-9_-]+/,relevance:0
+},{className:"selector-class",begin:"\\.[a-zA-Z-][a-zA-Z0-9_-]*",relevance:0
+},t.ATTRIBUTE_SELECTOR_MODE,{className:"selector-pseudo",variants:[{
+begin:":("+oe.join("|")+")"},{begin:":(:)?("+le.join("|")+")"}]
+},t.CSS_VARIABLE,{className:"attribute",begin:"\\b("+ce.join("|")+")\\b"},{
+begin:/:/,end:/[;}{]/,
+contains:[t.BLOCK_COMMENT,t.HEXCOLOR,t.IMPORTANT,t.CSS_NUMBER_MODE,...a,{
+begin:/(url|data-uri)\(/,end:/\)/,relevance:0,keywords:{built_in:"url data-uri"
+},contains:[...a,{className:"string",begin:/[^)]/,endsWithParent:!0,
+excludeEnd:!0}]},t.FUNCTION_DISPATCH]},{begin:n.lookahead(/@/),end:"[{;]",
+relevance:0,illegal:/:/,contains:[{className:"keyword",begin:/@-?\w[\w]*(-\w+)*/
+},{begin:/\s/,endsWithParent:!0,excludeEnd:!0,relevance:0,keywords:{
+$pattern:/[a-z-]+/,keyword:"and or not only",attribute:se.join(" ")},contains:[{
+begin:/[a-z-]+(?=:)/,className:"attribute"},...a,t.CSS_NUMBER_MODE]}]},{
+className:"selector-tag",begin:"\\b("+re.join("|")+")\\b"}]}},grmr_diff:e=>{
+const n=e.regex;return{name:"Diff",aliases:["patch"],contains:[{
+className:"meta",relevance:10,
+match:n.either(/^@@ +-\d+,\d+ +\+\d+,\d+ +@@/,/^\*\*\* +\d+,\d+ +\*\*\*\*$/,/^--- +\d+,\d+ +----$/)
+},{className:"comment",variants:[{
+begin:n.either(/Index: /,/^index/,/={3,}/,/^-{3}/,/^\*{3} /,/^\+{3}/,/^diff --git/),
+end:/$/},{match:/^\*{15}$/}]},{className:"addition",begin:/^\+/,end:/$/},{
+className:"deletion",begin:/^-/,end:/$/},{className:"addition",begin:/^!/,
+end:/$/}]}},grmr_go:e=>{const n={
+keyword:["break","case","chan","const","continue","default","defer","else","fallthrough","for","func","go","goto","if","import","interface","map","package","range","return","select","struct","switch","type","var"],
+type:["bool","byte","complex64","complex128","error","float32","float64","int8","int16","int32","int64","string","uint8","uint16","uint32","uint64","int","uint","uintptr","rune"],
+literal:["true","false","iota","nil"],
+built_in:["append","cap","close","complex","copy","imag","len","make","new","panic","print","println","real","recover","delete"]
+};return{name:"Go",aliases:["golang"],keywords:n,illegal:"</",
+contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{className:"string",
+variants:[e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{begin:"`",end:"`"}]},{
+className:"number",variants:[{begin:e.C_NUMBER_RE+"[i]",relevance:1
+},e.C_NUMBER_MODE]},{begin:/:=/},{className:"function",beginKeywords:"func",
+end:"\\s*(\\{|$)",excludeEnd:!0,contains:[e.TITLE_MODE,{className:"params",
+begin:/\(/,end:/\)/,endsParent:!0,keywords:n,illegal:/["']/}]}]}},
+grmr_graphql:e=>{const n=e.regex;return{name:"GraphQL",aliases:["gql"],
+case_insensitive:!0,disableAutodetect:!1,keywords:{
+keyword:["query","mutation","subscription","type","input","schema","directive","interface","union","scalar","fragment","enum","on"],
+literal:["true","false","null"]},
+contains:[e.HASH_COMMENT_MODE,e.QUOTE_STRING_MODE,e.NUMBER_MODE,{
+scope:"punctuation",match:/[.]{3}/,relevance:0},{scope:"punctuation",
+begin:/[\!\(\)\:\=\[\]\{\|\}]{1}/,relevance:0},{scope:"variable",begin:/\$/,
+end:/\W/,excludeEnd:!0,relevance:0},{scope:"meta",match:/@\w+/,excludeEnd:!0},{
+scope:"symbol",begin:n.concat(/[_A-Za-z][_0-9A-Za-z]*/,n.lookahead(/\s*:/)),
+relevance:0}],illegal:[/[;<']/,/BEGIN/]}},grmr_ini:e=>{const n=e.regex,t={
+className:"number",relevance:0,variants:[{begin:/([+-]+)?[\d]+_[\d_]+/},{
+begin:e.NUMBER_RE}]},a=e.COMMENT();a.variants=[{begin:/;/,end:/$/},{begin:/#/,
+end:/$/}];const i={className:"variable",variants:[{begin:/\$[\w\d"][\w\d_]*/},{
+begin:/\$\{(.*?)\}/}]},r={className:"literal",
+begin:/\bon|off|true|false|yes|no\b/},s={className:"string",
+contains:[e.BACKSLASH_ESCAPE],variants:[{begin:"'''",end:"'''",relevance:10},{
+begin:'"""',end:'"""',relevance:10},{begin:'"',end:'"'},{begin:"'",end:"'"}]
+},o={begin:/\[/,end:/\]/,contains:[a,r,i,s,t,"self"],relevance:0
+},l=n.either(/[A-Za-z0-9_-]+/,/"(\\"|[^"])*"/,/'[^']*'/);return{
+name:"TOML, also INI",aliases:["toml"],case_insensitive:!0,illegal:/\S/,
+contains:[a,{className:"section",begin:/\[+/,end:/\]+/},{
+begin:n.concat(l,"(\\s*\\.\\s*",l,")*",n.lookahead(/\s*=\s*[^#\s]/)),
+className:"attr",starts:{end:/$/,contains:[a,o,r,i,s,t]}}]}},grmr_java:e=>{
+const n=e.regex,t="[\xc0-\u02b8a-zA-Z_$][\xc0-\u02b8a-zA-Z_$0-9]*",a=t+pe("(?:<"+t+"~~~(?:\\s*,\\s*"+t+"~~~)*>)?",/~~~/g,2),i={
+keyword:["synchronized","abstract","private","var","static","if","const ","for","while","strictfp","finally","protected","import","native","final","void","enum","else","break","transient","catch","instanceof","volatile","case","assert","package","default","public","try","switch","continue","throws","protected","public","private","module","requires","exports","do","sealed","yield","permits"],
+literal:["false","true","null"],
+type:["char","boolean","long","float","int","byte","short","double"],
+built_in:["super","this"]},r={className:"meta",begin:"@"+t,contains:[{
+begin:/\(/,end:/\)/,contains:["self"]}]},s={className:"params",begin:/\(/,
+end:/\)/,keywords:i,relevance:0,contains:[e.C_BLOCK_COMMENT_MODE],endsParent:!0}
+;return{name:"Java",aliases:["jsp"],keywords:i,illegal:/<\/|#/,
+contains:[e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{begin:/\w+@/,
+relevance:0},{className:"doctag",begin:"@[A-Za-z]+"}]}),{
+begin:/import java\.[a-z]+\./,keywords:"import",relevance:2
+},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,{begin:/"""/,end:/"""/,
+className:"string",contains:[e.BACKSLASH_ESCAPE]
+},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{
+match:[/\b(?:class|interface|enum|extends|implements|new)/,/\s+/,t],className:{
+1:"keyword",3:"title.class"}},{match:/non-sealed/,scope:"keyword"},{
+begin:[n.concat(/(?!else)/,t),/\s+/,t,/\s+/,/=(?!=)/],className:{1:"type",
+3:"variable",5:"operator"}},{begin:[/record/,/\s+/,t],className:{1:"keyword",
+3:"title.class"},contains:[s,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{
+beginKeywords:"new throw return else",relevance:0},{
+begin:["(?:"+a+"\\s+)",e.UNDERSCORE_IDENT_RE,/\s*(?=\()/],className:{
+2:"title.function"},keywords:i,contains:[{className:"params",begin:/\(/,
+end:/\)/,keywords:i,relevance:0,
+contains:[r,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,me,e.C_BLOCK_COMMENT_MODE]
+},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},me,r]}},grmr_javascript:Oe,
+grmr_json:e=>{const n=["true","false","null"],t={scope:"literal",
+beginKeywords:n.join(" ")};return{name:"JSON",keywords:{literal:n},contains:[{
+className:"attr",begin:/"(\\.|[^\\"\r\n])*"(?=\s*:)/,relevance:1.01},{
+match:/[{}[\],:]/,className:"punctuation",relevance:0
+},e.QUOTE_STRING_MODE,t,e.C_NUMBER_MODE,e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE],
+illegal:"\\S"}},grmr_kotlin:e=>{const n={
+keyword:"abstract as val var vararg get set class object open private protected public noinline crossinline dynamic final enum if else do while for when throw try catch finally import package is in fun override companion reified inline lateinit init interface annotation data sealed internal infix operator out by constructor super tailrec where const inner suspend typealias external expect actual",
+built_in:"Byte Short Char Int Long Boolean Float Double Void Unit Nothing",
+literal:"true false null"},t={className:"symbol",begin:e.UNDERSCORE_IDENT_RE+"@"
+},a={className:"subst",begin:/\$\{/,end:/\}/,contains:[e.C_NUMBER_MODE]},i={
+className:"variable",begin:"\\$"+e.UNDERSCORE_IDENT_RE},r={className:"string",
+variants:[{begin:'"""',end:'"""(?=[^"])',contains:[i,a]},{begin:"'",end:"'",
+illegal:/\n/,contains:[e.BACKSLASH_ESCAPE]},{begin:'"',end:'"',illegal:/\n/,
+contains:[e.BACKSLASH_ESCAPE,i,a]}]};a.contains.push(r);const s={
+className:"meta",
+begin:"@(?:file|property|field|get|set|receiver|param|setparam|delegate)\\s*:(?:\\s*"+e.UNDERSCORE_IDENT_RE+")?"
+},o={className:"meta",begin:"@"+e.UNDERSCORE_IDENT_RE,contains:[{begin:/\(/,
+end:/\)/,contains:[e.inherit(r,{className:"string"}),"self"]}]
+},l=me,c=e.COMMENT("/\\*","\\*/",{contains:[e.C_BLOCK_COMMENT_MODE]}),d={
+variants:[{className:"type",begin:e.UNDERSCORE_IDENT_RE},{begin:/\(/,end:/\)/,
+contains:[]}]},g=d;return g.variants[1].contains=[d],d.variants[1].contains=[g],
+{name:"Kotlin",aliases:["kt","kts"],keywords:n,
+contains:[e.COMMENT("/\\*\\*","\\*/",{relevance:0,contains:[{className:"doctag",
+begin:"@[A-Za-z]+"}]}),e.C_LINE_COMMENT_MODE,c,{className:"keyword",
+begin:/\b(break|continue|return|this)\b/,starts:{contains:[{className:"symbol",
+begin:/@\w+/}]}},t,s,o,{className:"function",beginKeywords:"fun",end:"[(]|$",
+returnBegin:!0,excludeEnd:!0,keywords:n,relevance:5,contains:[{
+begin:e.UNDERSCORE_IDENT_RE+"\\s*\\(",returnBegin:!0,relevance:0,
+contains:[e.UNDERSCORE_TITLE_MODE]},{className:"type",begin:/</,end:/>/,
+keywords:"reified",relevance:0},{className:"params",begin:/\(/,end:/\)/,
+endsParent:!0,keywords:n,relevance:0,contains:[{begin:/:/,end:/[=,\/]/,
+endsWithParent:!0,contains:[d,e.C_LINE_COMMENT_MODE,c],relevance:0
+},e.C_LINE_COMMENT_MODE,c,s,o,r,e.C_NUMBER_MODE]},c]},{
+begin:[/class|interface|trait/,/\s+/,e.UNDERSCORE_IDENT_RE],beginScope:{
+3:"title.class"},keywords:"class interface trait",end:/[:\{(]|$/,excludeEnd:!0,
+illegal:"extends implements",contains:[{
+beginKeywords:"public protected internal private constructor"
+},e.UNDERSCORE_TITLE_MODE,{className:"type",begin:/</,end:/>/,excludeBegin:!0,
+excludeEnd:!0,relevance:0},{className:"type",begin:/[,:]\s*/,end:/[<\(,){\s]|$/,
+excludeBegin:!0,returnEnd:!0},s,o]},r,{className:"meta",begin:"^#!/usr/bin/env",
+end:"$",illegal:"\n"},l]}},grmr_less:e=>{
+const n=ie(e),t=de,a="[\\w-]+",i="("+a+"|@\\{"+a+"\\})",r=[],s=[],o=e=>({
+className:"string",begin:"~?"+e+".*?"+e}),l=(e,n,t)=>({className:e,begin:n,
+relevance:t}),c={$pattern:/[a-z-]+/,keyword:"and or not only",
+attribute:se.join(" ")},d={begin:"\\(",end:"\\)",contains:s,keywords:c,
+relevance:0}
+;s.push(e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,o("'"),o('"'),n.CSS_NUMBER_MODE,{
+begin:"(url|data-uri)\\(",starts:{className:"string",end:"[\\)\\n]",
+excludeEnd:!0}
+},n.HEXCOLOR,d,l("variable","@@?"+a,10),l("variable","@\\{"+a+"\\}"),l("built_in","~?`[^`]*?`"),{
+className:"attribute",begin:a+"\\s*:",end:":",returnBegin:!0,excludeEnd:!0
+},n.IMPORTANT,{beginKeywords:"and not"},n.FUNCTION_DISPATCH);const g=s.concat({
+begin:/\{/,end:/\}/,contains:r}),u={beginKeywords:"when",endsWithParent:!0,
+contains:[{beginKeywords:"and not"}].concat(s)},b={begin:i+"\\s*:",
+returnBegin:!0,end:/[;}]/,relevance:0,contains:[{begin:/-(webkit|moz|ms|o)-/
+},n.CSS_VARIABLE,{className:"attribute",begin:"\\b("+ce.join("|")+")\\b",
+end:/(?=:)/,starts:{endsWithParent:!0,illegal:"[<=$]",relevance:0,contains:s}}]
+},m={className:"keyword",
+begin:"@(import|media|charset|font-face|(-[a-z]+-)?keyframes|supports|document|namespace|page|viewport|host)\\b",
+starts:{end:"[;{}]",keywords:c,returnEnd:!0,contains:s,relevance:0}},p={
+className:"variable",variants:[{begin:"@"+a+"\\s*:",relevance:15},{begin:"@"+a
+}],starts:{end:"[;}]",returnEnd:!0,contains:g}},_={variants:[{
+begin:"[\\.#:&\\[>]",end:"[;{}]"},{begin:i,end:/\{/}],returnBegin:!0,
+returnEnd:!0,illegal:"[<='$\"]",relevance:0,
+contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,u,l("keyword","all\\b"),l("variable","@\\{"+a+"\\}"),{
+begin:"\\b("+re.join("|")+")\\b",className:"selector-tag"
+},n.CSS_NUMBER_MODE,l("selector-tag",i,0),l("selector-id","#"+i),l("selector-class","\\."+i,0),l("selector-tag","&",0),n.ATTRIBUTE_SELECTOR_MODE,{
+className:"selector-pseudo",begin:":("+oe.join("|")+")"},{
+className:"selector-pseudo",begin:":(:)?("+le.join("|")+")"},{begin:/\(/,
+end:/\)/,relevance:0,contains:g},{begin:"!important"},n.FUNCTION_DISPATCH]},h={
+begin:a+":(:)?"+`(${t.join("|")})`,returnBegin:!0,contains:[_]}
+;return r.push(e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,m,p,h,b,_,u,n.FUNCTION_DISPATCH),
+{name:"Less",case_insensitive:!0,illegal:"[=>'/<($\"]",contains:r}},
+grmr_lua:e=>{const n="\\[=*\\[",t="\\]=*\\]",a={begin:n,end:t,contains:["self"]
+},i=[e.COMMENT("--(?!"+n+")","$"),e.COMMENT("--"+n,t,{contains:[a],relevance:10
+})];return{name:"Lua",keywords:{$pattern:e.UNDERSCORE_IDENT_RE,
+literal:"true false nil",
+keyword:"and break do else elseif end for goto if in local not or repeat return then until while",
+built_in:"_G _ENV _VERSION __index __newindex __mode __call __metatable __tostring __len __gc __add __sub __mul __div __mod __pow __concat __unm __eq __lt __le assert collectgarbage dofile error getfenv getmetatable ipairs load loadfile loadstring module next pairs pcall print rawequal rawget rawset require select setfenv setmetatable tonumber tostring type unpack xpcall arg self coroutine resume yield status wrap create running debug getupvalue debug sethook getmetatable gethook setmetatable setlocal traceback setfenv getinfo setupvalue getlocal getregistry getfenv io lines write close flush open output type read stderr stdin input stdout popen tmpfile math log max acos huge ldexp pi cos tanh pow deg tan cosh sinh random randomseed frexp ceil floor rad abs sqrt modf asin min mod fmod log10 atan2 exp sin atan os exit setlocale date getenv difftime remove time clock tmpname rename execute package preload loadlib loaded loaders cpath config path seeall string sub upper len gfind rep find match char dump gmatch reverse byte format gsub lower table setn insert getn foreachi maxn foreach concat sort remove"
+},contains:i.concat([{className:"function",beginKeywords:"function",end:"\\)",
+contains:[e.inherit(e.TITLE_MODE,{
+begin:"([_a-zA-Z]\\w*\\.)*([_a-zA-Z]\\w*:)?[_a-zA-Z]\\w*"}),{className:"params",
+begin:"\\(",endsWithParent:!0,contains:i}].concat(i)
+},e.C_NUMBER_MODE,e.APOS_STRING_MODE,e.QUOTE_STRING_MODE,{className:"string",
+begin:n,end:t,contains:[a],relevance:5}])}},grmr_makefile:e=>{const n={
+className:"variable",variants:[{begin:"\\$\\("+e.UNDERSCORE_IDENT_RE+"\\)",
+contains:[e.BACKSLASH_ESCAPE]},{begin:/\$[@%<?\^\+\*]/}]},t={className:"string",
+begin:/"/,end:/"/,contains:[e.BACKSLASH_ESCAPE,n]},a={className:"variable",
+begin:/\$\([\w-]+\s/,end:/\)/,keywords:{
+built_in:"subst patsubst strip findstring filter filter-out sort word wordlist firstword lastword dir notdir suffix basename addsuffix addprefix join wildcard realpath abspath error warning shell origin flavor foreach if or and call eval file value"
+},contains:[n]},i={begin:"^"+e.UNDERSCORE_IDENT_RE+"\\s*(?=[:+?]?=)"},r={
+className:"section",begin:/^[^\s]+:/,end:/$/,contains:[n]};return{
+name:"Makefile",aliases:["mk","mak","make"],keywords:{$pattern:/[\w-]+/,
+keyword:"define endef undefine ifdef ifndef ifeq ifneq else endif include -include sinclude override export unexport private vpath"
+},contains:[e.HASH_COMMENT_MODE,n,t,a,i,{className:"meta",begin:/^\.PHONY:/,
+end:/$/,keywords:{$pattern:/[\.\w]+/,keyword:".PHONY"}},r]}},grmr_markdown:e=>{
+const n={begin:/<\/?[A-Za-z_]/,end:">",subLanguage:"xml",relevance:0},t={
+variants:[{begin:/\[.+?\]\[.*?\]/,relevance:0},{
+begin:/\[.+?\]\(((data|javascript|mailto):|(?:http|ftp)s?:\/\/).*?\)/,
+relevance:2},{
+begin:e.regex.concat(/\[.+?\]\(/,/[A-Za-z][A-Za-z0-9+.-]*/,/:\/\/.*?\)/),
+relevance:2},{begin:/\[.+?\]\([./?&#].*?\)/,relevance:1},{
+begin:/\[.*?\]\(.*?\)/,relevance:0}],returnBegin:!0,contains:[{match:/\[(?=\])/
+},{className:"string",relevance:0,begin:"\\[",end:"\\]",excludeBegin:!0,
+returnEnd:!0},{className:"link",relevance:0,begin:"\\]\\(",end:"\\)",
+excludeBegin:!0,excludeEnd:!0},{className:"symbol",relevance:0,begin:"\\]\\[",
+end:"\\]",excludeBegin:!0,excludeEnd:!0}]},a={className:"strong",contains:[],
+variants:[{begin:/_{2}(?!\s)/,end:/_{2}/},{begin:/\*{2}(?!\s)/,end:/\*{2}/}]
+},i={className:"emphasis",contains:[],variants:[{begin:/\*(?![*\s])/,end:/\*/},{
+begin:/_(?![_\s])/,end:/_/,relevance:0}]},r=e.inherit(a,{contains:[]
+}),s=e.inherit(i,{contains:[]});a.contains.push(s),i.contains.push(r)
+;let o=[n,t];return[a,i,r,s].forEach((e=>{e.contains=e.contains.concat(o)
+})),o=o.concat(a,i),{name:"Markdown",aliases:["md","mkdown","mkd"],contains:[{
+className:"section",variants:[{begin:"^#{1,6}",end:"$",contains:o},{
+begin:"(?=^.+?\\n[=-]{2,}$)",contains:[{begin:"^[=-]*$"},{begin:"^",end:"\\n",
+contains:o}]}]},n,{className:"bullet",begin:"^[ \t]*([*+-]|(\\d+\\.))(?=\\s+)",
+end:"\\s+",excludeEnd:!0},a,i,{className:"quote",begin:"^>\\s+",contains:o,
+end:"$"},{className:"code",variants:[{begin:"(`{3,})[^`](.|\\n)*?\\1`*[ ]*"},{
+begin:"(~{3,})[^~](.|\\n)*?\\1~*[ ]*"},{begin:"```",end:"```+[ ]*$"},{
+begin:"~~~",end:"~~~+[ ]*$"},{begin:"`.+?`"},{begin:"(?=^( {4}|\\t))",
+contains:[{begin:"^( {4}|\\t)",end:"(\\n)$"}],relevance:0}]},{
+begin:"^[-\\*]{3,}",end:"$"},t,{begin:/^\[[^\n]+\]:/,returnBegin:!0,contains:[{
+className:"symbol",begin:/\[/,end:/\]/,excludeBegin:!0,excludeEnd:!0},{
+className:"link",begin:/:\s*/,end:/$/,excludeBegin:!0}]}]}},grmr_objectivec:e=>{
+const n=/[a-zA-Z@][a-zA-Z0-9_]*/,t={$pattern:n,
+keyword:["@interface","@class","@protocol","@implementation"]};return{
+name:"Objective-C",aliases:["mm","objc","obj-c","obj-c++","objective-c++"],
+keywords:{"variable.language":["this","super"],$pattern:n,
+keyword:["while","export","sizeof","typedef","const","struct","for","union","volatile","static","mutable","if","do","return","goto","enum","else","break","extern","asm","case","default","register","explicit","typename","switch","continue","inline","readonly","assign","readwrite","self","@synchronized","id","typeof","nonatomic","IBOutlet","IBAction","strong","weak","copy","in","out","inout","bycopy","byref","oneway","__strong","__weak","__block","__autoreleasing","@private","@protected","@public","@try","@property","@end","@throw","@catch","@finally","@autoreleasepool","@synthesize","@dynamic","@selector","@optional","@required","@encode","@package","@import","@defs","@compatibility_alias","__bridge","__bridge_transfer","__bridge_retained","__bridge_retain","__covariant","__contravariant","__kindof","_Nonnull","_Nullable","_Null_unspecified","__FUNCTION__","__PRETTY_FUNCTION__","__attribute__","getter","setter","retain","unsafe_unretained","nonnull","nullable","null_unspecified","null_resettable","class","instancetype","NS_DESIGNATED_INITIALIZER","NS_UNAVAILABLE","NS_REQUIRES_SUPER","NS_RETURNS_INNER_POINTER","NS_INLINE","NS_AVAILABLE","NS_DEPRECATED","NS_ENUM","NS_OPTIONS","NS_SWIFT_UNAVAILABLE","NS_ASSUME_NONNULL_BEGIN","NS_ASSUME_NONNULL_END","NS_REFINED_FOR_SWIFT","NS_SWIFT_NAME","NS_SWIFT_NOTHROW","NS_DURING","NS_HANDLER","NS_ENDHANDLER","NS_VALUERETURN","NS_VOIDRETURN"],
+literal:["false","true","FALSE","TRUE","nil","YES","NO","NULL"],
+built_in:["dispatch_once_t","dispatch_queue_t","dispatch_sync","dispatch_async","dispatch_once"],
+type:["int","float","char","unsigned","signed","short","long","double","wchar_t","unichar","void","bool","BOOL","id|0","_Bool"]
+},illegal:"</",contains:[{className:"built_in",
+begin:"\\b(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)\\w+"
+},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,e.C_NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,{
+className:"string",variants:[{begin:'@"',end:'"',illegal:"\\n",
+contains:[e.BACKSLASH_ESCAPE]}]},{className:"meta",begin:/#\s*[a-z]+\b/,end:/$/,
+keywords:{
+keyword:"if else elif endif define undef warning error line pragma ifdef ifndef include"
+},contains:[{begin:/\\\n/,relevance:0},e.inherit(e.QUOTE_STRING_MODE,{
+className:"string"}),{className:"string",begin:/<.*?>/,end:/$/,illegal:"\\n"
+},e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE]},{className:"class",
+begin:"("+t.keyword.join("|")+")\\b",end:/(\{|$)/,excludeEnd:!0,keywords:t,
+contains:[e.UNDERSCORE_TITLE_MODE]},{begin:"\\."+e.UNDERSCORE_IDENT_RE,
+relevance:0}]}},grmr_perl:e=>{const n=e.regex,t=/[dualxmsipngr]{0,12}/,a={
+$pattern:/[\w.]+/,
+keyword:"abs accept alarm and atan2 bind binmode bless break caller chdir chmod chomp chop chown chr chroot close closedir connect continue cos crypt dbmclose dbmopen defined delete die do dump each else elsif endgrent endhostent endnetent endprotoent endpwent endservent eof eval exec exists exit exp fcntl fileno flock for foreach fork format formline getc getgrent getgrgid getgrnam gethostbyaddr gethostbyname gethostent getlogin getnetbyaddr getnetbyname getnetent getpeername getpgrp getpriority getprotobyname getprotobynumber getprotoent getpwent getpwnam getpwuid getservbyname getservbyport getservent getsockname getsockopt given glob gmtime goto grep gt hex if index int ioctl join keys kill last lc lcfirst length link listen local localtime log lstat lt ma map mkdir msgctl msgget msgrcv msgsnd my ne next no not oct open opendir or ord our pack package pipe pop pos print printf prototype push q|0 qq quotemeta qw qx rand read readdir readline readlink readpipe recv redo ref rename require reset return reverse rewinddir rindex rmdir say scalar seek seekdir select semctl semget semop send setgrent sethostent setnetent setpgrp setpriority setprotoent setpwent setservent setsockopt shift shmctl shmget shmread shmwrite shutdown sin sleep socket socketpair sort splice split sprintf sqrt srand stat state study sub substr symlink syscall sysopen sysread sysseek system syswrite tell telldir tie tied time times tr truncate uc ucfirst umask undef unless unlink unpack unshift untie until use utime values vec wait waitpid wantarray warn when while write x|0 xor y|0"
+},i={className:"subst",begin:"[$@]\\{",end:"\\}",keywords:a},r={begin:/->\{/,
+end:/\}/},s={variants:[{begin:/\$\d/},{
+begin:n.concat(/[$%@](\^\w\b|#\w+(::\w+)*|\{\w+\}|\w+(::\w*)*)/,"(?![A-Za-z])(?![@$%])")
+},{begin:/[$%@][^\s\w{]/,relevance:0}]
+},o=[e.BACKSLASH_ESCAPE,i,s],l=[/!/,/\//,/\|/,/\?/,/'/,/"/,/#/],c=(e,a,i="\\1")=>{
+const r="\\1"===i?i:n.concat(i,a)
+;return n.concat(n.concat("(?:",e,")"),a,/(?:\\.|[^\\\/])*?/,r,/(?:\\.|[^\\\/])*?/,i,t)
+},d=(e,a,i)=>n.concat(n.concat("(?:",e,")"),a,/(?:\\.|[^\\\/])*?/,i,t),g=[s,e.HASH_COMMENT_MODE,e.COMMENT(/^=\w/,/=cut/,{
+endsWithParent:!0}),r,{className:"string",contains:o,variants:[{
+begin:"q[qwxr]?\\s*\\(",end:"\\)",relevance:5},{begin:"q[qwxr]?\\s*\\[",
+end:"\\]",relevance:5},{begin:"q[qwxr]?\\s*\\{",end:"\\}",relevance:5},{
+begin:"q[qwxr]?\\s*\\|",end:"\\|",relevance:5},{begin:"q[qwxr]?\\s*<",end:">",
+relevance:5},{begin:"qw\\s+q",end:"q",relevance:5},{begin:"'",end:"'",
+contains:[e.BACKSLASH_ESCAPE]},{begin:'"',end:'"'},{begin:"`",end:"`",
+contains:[e.BACKSLASH_ESCAPE]},{begin:/\{\w+\}/,relevance:0},{
+begin:"-?\\w+\\s*=>",relevance:0}]},{className:"number",
+begin:"(\\b0[0-7_]+)|(\\b0x[0-9a-fA-F_]+)|(\\b[1-9][0-9_]*(\\.[0-9_]+)?)|[0_]\\b",
+relevance:0},{
+begin:"(\\/\\/|"+e.RE_STARTERS_RE+"|\\b(split|return|print|reverse|grep)\\b)\\s*",
+keywords:"split return print reverse grep",relevance:0,
+contains:[e.HASH_COMMENT_MODE,{className:"regexp",variants:[{
+begin:c("s|tr|y",n.either(...l,{capture:!0}))},{begin:c("s|tr|y","\\(","\\)")},{
+begin:c("s|tr|y","\\[","\\]")},{begin:c("s|tr|y","\\{","\\}")}],relevance:2},{
+className:"regexp",variants:[{begin:/(m|qr)\/\//,relevance:0},{
+begin:d("(?:m|qr)?",/\//,/\//)},{begin:d("m|qr",n.either(...l,{capture:!0
+}),/\1/)},{begin:d("m|qr",/\(/,/\)/)},{begin:d("m|qr",/\[/,/\]/)},{
+begin:d("m|qr",/\{/,/\}/)}]}]},{className:"function",beginKeywords:"sub",
+end:"(\\s*\\(.*?\\))?[;{]",excludeEnd:!0,relevance:5,contains:[e.TITLE_MODE]},{
+begin:"-\\w\\b",relevance:0},{begin:"^__DATA__$",end:"^__END__$",
+subLanguage:"mojolicious",contains:[{begin:"^@@.*",end:"$",className:"comment"}]
+}];return i.contains=g,r.contains=g,{name:"Perl",aliases:["pl","pm"],keywords:a,
+contains:g}},grmr_php:e=>{
+const n=e.regex,t=/(?![A-Za-z0-9])(?![$])/,a=n.concat(/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/,t),i=n.concat(/(\\?[A-Z][a-z0-9_\x7f-\xff]+|\\?[A-Z]+(?=[A-Z][a-z0-9_\x7f-\xff])){1,}/,t),r={
+scope:"variable",match:"\\$+"+a},s={scope:"subst",variants:[{begin:/\$\w+/},{
+begin:/\{\$/,end:/\}/}]},o=e.inherit(e.APOS_STRING_MODE,{illegal:null
+}),l="[ \t\n]",c={scope:"string",variants:[e.inherit(e.QUOTE_STRING_MODE,{
+illegal:null,contains:e.QUOTE_STRING_MODE.contains.concat(s)}),o,{
+begin:/<<<[ \t]*(?:(\w+)|"(\w+)")\n/,end:/[ \t]*(\w+)\b/,
+contains:e.QUOTE_STRING_MODE.contains.concat(s),"on:begin":(e,n)=>{
+n.data._beginMatch=e[1]||e[2]},"on:end":(e,n)=>{
+n.data._beginMatch!==e[1]&&n.ignoreMatch()}},e.END_SAME_AS_BEGIN({
+begin:/<<<[ \t]*'(\w+)'\n/,end:/[ \t]*(\w+)\b/})]},d={scope:"number",variants:[{
+begin:"\\b0[bB][01]+(?:_[01]+)*\\b"},{begin:"\\b0[oO][0-7]+(?:_[0-7]+)*\\b"},{
+begin:"\\b0[xX][\\da-fA-F]+(?:_[\\da-fA-F]+)*\\b"},{
+begin:"(?:\\b\\d+(?:_\\d+)*(\\.(?:\\d+(?:_\\d+)*))?|\\B\\.\\d+)(?:[eE][+-]?\\d+)?"
+}],relevance:0
+},g=["false","null","true"],u=["__CLASS__","__DIR__","__FILE__","__FUNCTION__","__COMPILER_HALT_OFFSET__","__LINE__","__METHOD__","__NAMESPACE__","__TRAIT__","die","echo","exit","include","include_once","print","require","require_once","array","abstract","and","as","binary","bool","boolean","break","callable","case","catch","class","clone","const","continue","declare","default","do","double","else","elseif","empty","enddeclare","endfor","endforeach","endif","endswitch","endwhile","enum","eval","extends","final","finally","float","for","foreach","from","global","goto","if","implements","instanceof","insteadof","int","integer","interface","isset","iterable","list","match|0","mixed","new","never","object","or","private","protected","public","readonly","real","return","string","switch","throw","trait","try","unset","use","var","void","while","xor","yield"],b=["Error|0","AppendIterator","ArgumentCountError","ArithmeticError","ArrayIterator","ArrayObject","AssertionError","BadFunctionCallException","BadMethodCallException","CachingIterator","CallbackFilterIterator","CompileError","Countable","DirectoryIterator","DivisionByZeroError","DomainException","EmptyIterator","ErrorException","Exception","FilesystemIterator","FilterIterator","GlobIterator","InfiniteIterator","InvalidArgumentException","IteratorIterator","LengthException","LimitIterator","LogicException","MultipleIterator","NoRewindIterator","OutOfBoundsException","OutOfRangeException","OuterIterator","OverflowException","ParentIterator","ParseError","RangeException","RecursiveArrayIterator","RecursiveCachingIterator","RecursiveCallbackFilterIterator","RecursiveDirectoryIterator","RecursiveFilterIterator","RecursiveIterator","RecursiveIteratorIterator","RecursiveRegexIterator","RecursiveTreeIterator","RegexIterator","RuntimeException","SeekableIterator","SplDoublyLinkedList","SplFileInfo","SplFileObject","SplFixedArray","SplHeap","SplMaxHeap","SplMinHeap","SplObjectStorage","SplObserver","SplPriorityQueue","SplQueue","SplStack","SplSubject","SplTempFileObject","TypeError","UnderflowException","UnexpectedValueException","UnhandledMatchError","ArrayAccess","BackedEnum","Closure","Fiber","Generator","Iterator","IteratorAggregate","Serializable","Stringable","Throwable","Traversable","UnitEnum","WeakReference","WeakMap","Directory","__PHP_Incomplete_Class","parent","php_user_filter","self","static","stdClass"],m={
+keyword:u,literal:(e=>{const n=[];return e.forEach((e=>{
+n.push(e),e.toLowerCase()===e?n.push(e.toUpperCase()):n.push(e.toLowerCase())
+})),n})(g),built_in:b},p=e=>e.map((e=>e.replace(/\|\d+$/,""))),_={variants:[{
+match:[/new/,n.concat(l,"+"),n.concat("(?!",p(b).join("\\b|"),"\\b)"),i],scope:{
+1:"keyword",4:"title.class"}}]},h=n.concat(a,"\\b(?!\\()"),f={variants:[{
+match:[n.concat(/::/,n.lookahead(/(?!class\b)/)),h],scope:{2:"variable.constant"
+}},{match:[/::/,/class/],scope:{2:"variable.language"}},{
+match:[i,n.concat(/::/,n.lookahead(/(?!class\b)/)),h],scope:{1:"title.class",
+3:"variable.constant"}},{match:[i,n.concat("::",n.lookahead(/(?!class\b)/))],
+scope:{1:"title.class"}},{match:[i,/::/,/class/],scope:{1:"title.class",
+3:"variable.language"}}]},E={scope:"attr",
+match:n.concat(a,n.lookahead(":"),n.lookahead(/(?!::)/))},y={relevance:0,
+begin:/\(/,end:/\)/,keywords:m,contains:[E,r,f,e.C_BLOCK_COMMENT_MODE,c,d,_]
+},N={relevance:0,
+match:[/\b/,n.concat("(?!fn\\b|function\\b|",p(u).join("\\b|"),"|",p(b).join("\\b|"),"\\b)"),a,n.concat(l,"*"),n.lookahead(/(?=\()/)],
+scope:{3:"title.function.invoke"},contains:[y]};y.contains.push(N)
+;const w=[E,f,e.C_BLOCK_COMMENT_MODE,c,d,_];return{case_insensitive:!1,
+keywords:m,contains:[{begin:n.concat(/#\[\s*/,i),beginScope:"meta",end:/]/,
+endScope:"meta",keywords:{literal:g,keyword:["new","array"]},contains:[{
+begin:/\[/,end:/]/,keywords:{literal:g,keyword:["new","array"]},
+contains:["self",...w]},...w,{scope:"meta",match:i}]
+},e.HASH_COMMENT_MODE,e.COMMENT("//","$"),e.COMMENT("/\\*","\\*/",{contains:[{
+scope:"doctag",match:"@[A-Za-z]+"}]}),{match:/__halt_compiler\(\);/,
+keywords:"__halt_compiler",starts:{scope:"comment",end:e.MATCH_NOTHING_RE,
+contains:[{match:/\?>/,scope:"meta",endsParent:!0}]}},{scope:"meta",variants:[{
+begin:/<\?php/,relevance:10},{begin:/<\?=/},{begin:/<\?/,relevance:.1},{
+begin:/\?>/}]},{scope:"variable.language",match:/\$this\b/},r,N,f,{
+match:[/const/,/\s/,a],scope:{1:"keyword",3:"variable.constant"}},_,{
+scope:"function",relevance:0,beginKeywords:"fn function",end:/[;{]/,
+excludeEnd:!0,illegal:"[$%\\[]",contains:[{beginKeywords:"use"
+},e.UNDERSCORE_TITLE_MODE,{begin:"=>",endsParent:!0},{scope:"params",
+begin:"\\(",end:"\\)",excludeBegin:!0,excludeEnd:!0,keywords:m,
+contains:["self",r,f,e.C_BLOCK_COMMENT_MODE,c,d]}]},{scope:"class",variants:[{
+beginKeywords:"enum",illegal:/[($"]/},{beginKeywords:"class interface trait",
+illegal:/[:($"]/}],relevance:0,end:/\{/,excludeEnd:!0,contains:[{
+beginKeywords:"extends implements"},e.UNDERSCORE_TITLE_MODE]},{
+beginKeywords:"namespace",relevance:0,end:";",illegal:/[.']/,
+contains:[e.inherit(e.UNDERSCORE_TITLE_MODE,{scope:"title.class"})]},{
+beginKeywords:"use",relevance:0,end:";",contains:[{
+match:/\b(as|const|function)\b/,scope:"keyword"},e.UNDERSCORE_TITLE_MODE]},c,d]}
+},grmr_php_template:e=>({name:"PHP template",subLanguage:"xml",contains:[{
+begin:/<\?(php|=)?/,end:/\?>/,subLanguage:"php",contains:[{begin:"/\\*",
+end:"\\*/",skip:!0},{begin:'b"',end:'"',skip:!0},{begin:"b'",end:"'",skip:!0
+},e.inherit(e.APOS_STRING_MODE,{illegal:null,className:null,contains:null,
+skip:!0}),e.inherit(e.QUOTE_STRING_MODE,{illegal:null,className:null,
+contains:null,skip:!0})]}]}),grmr_plaintext:e=>({name:"Plain text",
+aliases:["text","txt"],disableAutodetect:!0}),grmr_python:e=>{
+const n=e.regex,t=/[\p{XID_Start}_]\p{XID_Continue}*/u,a=["and","as","assert","async","await","break","case","class","continue","def","del","elif","else","except","finally","for","from","global","if","import","in","is","lambda","match","nonlocal|10","not","or","pass","raise","return","try","while","with","yield"],i={
+$pattern:/[A-Za-z]\w+|__\w+__/,keyword:a,
+built_in:["__import__","abs","all","any","ascii","bin","bool","breakpoint","bytearray","bytes","callable","chr","classmethod","compile","complex","delattr","dict","dir","divmod","enumerate","eval","exec","filter","float","format","frozenset","getattr","globals","hasattr","hash","help","hex","id","input","int","isinstance","issubclass","iter","len","list","locals","map","max","memoryview","min","next","object","oct","open","ord","pow","print","property","range","repr","reversed","round","set","setattr","slice","sorted","staticmethod","str","sum","super","tuple","type","vars","zip"],
+literal:["__debug__","Ellipsis","False","None","NotImplemented","True"],
+type:["Any","Callable","Coroutine","Dict","List","Literal","Generic","Optional","Sequence","Set","Tuple","Type","Union"]
+},r={className:"meta",begin:/^(>>>|\.\.\.) /},s={className:"subst",begin:/\{/,
+end:/\}/,keywords:i,illegal:/#/},o={begin:/\{\{/,relevance:0},l={
+className:"string",contains:[e.BACKSLASH_ESCAPE],variants:[{
+begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?'''/,end:/'''/,
+contains:[e.BACKSLASH_ESCAPE,r],relevance:10},{
+begin:/([uU]|[bB]|[rR]|[bB][rR]|[rR][bB])?"""/,end:/"""/,
+contains:[e.BACKSLASH_ESCAPE,r],relevance:10},{
+begin:/([fF][rR]|[rR][fF]|[fF])'''/,end:/'''/,
+contains:[e.BACKSLASH_ESCAPE,r,o,s]},{begin:/([fF][rR]|[rR][fF]|[fF])"""/,
+end:/"""/,contains:[e.BACKSLASH_ESCAPE,r,o,s]},{begin:/([uU]|[rR])'/,end:/'/,
+relevance:10},{begin:/([uU]|[rR])"/,end:/"/,relevance:10},{
+begin:/([bB]|[bB][rR]|[rR][bB])'/,end:/'/},{begin:/([bB]|[bB][rR]|[rR][bB])"/,
+end:/"/},{begin:/([fF][rR]|[rR][fF]|[fF])'/,end:/'/,
+contains:[e.BACKSLASH_ESCAPE,o,s]},{begin:/([fF][rR]|[rR][fF]|[fF])"/,end:/"/,
+contains:[e.BACKSLASH_ESCAPE,o,s]},e.APOS_STRING_MODE,e.QUOTE_STRING_MODE]
+},c="[0-9](_?[0-9])*",d=`(\\b(${c}))?\\.(${c})|\\b(${c})\\.`,g="\\b|"+a.join("|"),u={
+className:"number",relevance:0,variants:[{
+begin:`(\\b(${c})|(${d}))[eE][+-]?(${c})[jJ]?(?=${g})`},{begin:`(${d})[jJ]?`},{
+begin:`\\b([1-9](_?[0-9])*|0+(_?0)*)[lLjJ]?(?=${g})`},{
+begin:`\\b0[bB](_?[01])+[lL]?(?=${g})`},{begin:`\\b0[oO](_?[0-7])+[lL]?(?=${g})`
+},{begin:`\\b0[xX](_?[0-9a-fA-F])+[lL]?(?=${g})`},{begin:`\\b(${c})[jJ](?=${g})`
+}]},b={className:"comment",begin:n.lookahead(/# type:/),end:/$/,keywords:i,
+contains:[{begin:/# type:/},{begin:/#/,end:/\b\B/,endsWithParent:!0}]},m={
+className:"params",variants:[{className:"",begin:/\(\s*\)/,skip:!0},{begin:/\(/,
+end:/\)/,excludeBegin:!0,excludeEnd:!0,keywords:i,
+contains:["self",r,u,l,e.HASH_COMMENT_MODE]}]};return s.contains=[l,u,r],{
+name:"Python",aliases:["py","gyp","ipython"],unicodeRegex:!0,keywords:i,
+illegal:/(<\/|\?)|=>/,contains:[r,u,{begin:/\bself\b/},{beginKeywords:"if",
+relevance:0},l,b,e.HASH_COMMENT_MODE,{match:[/\bdef/,/\s+/,t],scope:{
+1:"keyword",3:"title.function"},contains:[m]},{variants:[{
+match:[/\bclass/,/\s+/,t,/\s*/,/\(\s*/,t,/\s*\)/]},{match:[/\bclass/,/\s+/,t]}],
+scope:{1:"keyword",3:"title.class",6:"title.class.inherited"}},{
+className:"meta",begin:/^[\t ]*@/,end:/(?=#)|$/,contains:[u,m,l]}]}},
+grmr_python_repl:e=>({aliases:["pycon"],contains:[{className:"meta.prompt",
+starts:{end:/ |$/,starts:{end:"$",subLanguage:"python"}},variants:[{
+begin:/^>>>(?=[ ]|$)/},{begin:/^\.\.\.(?=[ ]|$)/}]}]}),grmr_r:e=>{
+const n=e.regex,t=/(?:(?:[a-zA-Z]|\.[._a-zA-Z])[._a-zA-Z0-9]*)|\.(?!\d)/,a=n.either(/0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*[pP][+-]?\d+i?/,/0[xX][0-9a-fA-F]+(?:[pP][+-]?\d+)?[Li]?/,/(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[Li]?/),i=/[=!<>:]=|\|\||&&|:::?|<-|<<-|->>|->|\|>|[-+*\/?!{{HIGHLIGHT_JS}}|:<=>@^~]|\*\*/,r=n.either(/[()]/,/[{}]/,/\[\[/,/[[\]]/,/\\/,/,/)
+;return{name:"R",keywords:{$pattern:t,
+keyword:"function if in break next repeat else for while",
+literal:"NULL NA TRUE FALSE Inf NaN NA_integer_|10 NA_real_|10 NA_character_|10 NA_complex_|10",
+built_in:"LETTERS letters month.abb month.name pi T F abs acos acosh all any anyNA Arg as.call as.character as.complex as.double as.environment as.integer as.logical as.null.default as.numeric as.raw asin asinh atan atanh attr attributes baseenv browser c call ceiling class Conj cos cosh cospi cummax cummin cumprod cumsum digamma dim dimnames emptyenv exp expression floor forceAndCall gamma gc.time globalenv Im interactive invisible is.array is.atomic is.call is.character is.complex is.double is.environment is.expression is.finite is.function is.infinite is.integer is.language is.list is.logical is.matrix is.na is.name is.nan is.null is.numeric is.object is.pairlist is.raw is.recursive is.single is.symbol lazyLoadDBfetch length lgamma list log max min missing Mod names nargs nzchar oldClass on.exit pos.to.env proc.time prod quote range Re rep retracemem return round seq_along seq_len seq.int sign signif sin sinh sinpi sqrt standardGeneric substitute sum switch tan tanh tanpi tracemem trigamma trunc unclass untracemem UseMethod xtfrm"
+},contains:[e.COMMENT(/#'/,/$/,{contains:[{scope:"doctag",match:/@examples/,
+starts:{end:n.lookahead(n.either(/\n^#'\s*(?=@[a-zA-Z]+)/,/\n^(?!#')/)),
+endsParent:!0}},{scope:"doctag",begin:"@param",end:/$/,contains:[{
+scope:"variable",variants:[{match:t},{match:/`(?:\\.|[^`\\])+`/}],endsParent:!0
+}]},{scope:"doctag",match:/@[a-zA-Z]+/},{scope:"keyword",match:/\\[a-zA-Z]+/}]
+}),e.HASH_COMMENT_MODE,{scope:"string",contains:[e.BACKSLASH_ESCAPE],
+variants:[e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\(/,end:/\)(-*)"/
+}),e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\{/,end:/\}(-*)"/
+}),e.END_SAME_AS_BEGIN({begin:/[rR]"(-*)\[/,end:/\](-*)"/
+}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\(/,end:/\)(-*)'/
+}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\{/,end:/\}(-*)'/
+}),e.END_SAME_AS_BEGIN({begin:/[rR]'(-*)\[/,end:/\](-*)'/}),{begin:'"',end:'"',
+relevance:0},{begin:"'",end:"'",relevance:0}]},{relevance:0,variants:[{scope:{
+1:"operator",2:"number"},match:[i,a]},{scope:{1:"operator",2:"number"},
+match:[/%[^%]*%/,a]},{scope:{1:"punctuation",2:"number"},match:[r,a]},{scope:{
+2:"number"},match:[/[^a-zA-Z0-9._]|^/,a]}]},{scope:{3:"operator"},
+match:[t,/\s+/,/<-/,/\s+/]},{scope:"operator",relevance:0,variants:[{match:i},{
+match:/%[^%]*%/}]},{scope:"punctuation",relevance:0,match:r},{begin:"`",end:"`",
+contains:[{begin:/\\./}]}]}},grmr_ruby:e=>{
+const n=e.regex,t="([a-zA-Z_]\\w*[!?=]?|[-+~]@|<<|>>|=~|===?|<=>|[<>]=?|\\*\\*|[-/+%^&*~`|]|\\[\\]=?)",a=n.either(/\b([A-Z]+[a-z0-9]+)+/,/\b([A-Z]+[a-z0-9]+)+[A-Z]+/),i=n.concat(a,/(::\w+)*/),r={
+"variable.constant":["__FILE__","__LINE__","__ENCODING__"],
+"variable.language":["self","super"],
+keyword:["alias","and","begin","BEGIN","break","case","class","defined","do","else","elsif","end","END","ensure","for","if","in","module","next","not","or","redo","require","rescue","retry","return","then","undef","unless","until","when","while","yield","include","extend","prepend","public","private","protected","raise","throw"],
+built_in:["proc","lambda","attr_accessor","attr_reader","attr_writer","define_method","private_constant","module_function"],
+literal:["true","false","nil"]},s={className:"doctag",begin:"@[A-Za-z]+"},o={
+begin:"#<",end:">"},l=[e.COMMENT("#","$",{contains:[s]
+}),e.COMMENT("^=begin","^=end",{contains:[s],relevance:10
+}),e.COMMENT("^__END__",e.MATCH_NOTHING_RE)],c={className:"subst",begin:/#\{/,
+end:/\}/,keywords:r},d={className:"string",contains:[e.BACKSLASH_ESCAPE,c],
+variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/`/,end:/`/},{
+begin:/%[qQwWx]?\(/,end:/\)/},{begin:/%[qQwWx]?\[/,end:/\]/},{
+begin:/%[qQwWx]?\{/,end:/\}/},{begin:/%[qQwWx]?</,end:/>/},{begin:/%[qQwWx]?\//,
+end:/\//},{begin:/%[qQwWx]?%/,end:/%/},{begin:/%[qQwWx]?-/,end:/-/},{
+begin:/%[qQwWx]?\|/,end:/\|/},{begin:/\B\?(\\\d{1,3})/},{
+begin:/\B\?(\\x[A-Fa-f0-9]{1,2})/},{begin:/\B\?(\\u\{?[A-Fa-f0-9]{1,6}\}?)/},{
+begin:/\B\?(\\M-\\C-|\\M-\\c|\\c\\M-|\\M-|\\C-\\M-)[\x20-\x7e]/},{
+begin:/\B\?\\(c|C-)[\x20-\x7e]/},{begin:/\B\?\\?\S/},{
+begin:n.concat(/<<[-~]?'?/,n.lookahead(/(\w+)(?=\W)[^\n]*\n(?:[^\n]*\n)*?\s*\1\b/)),
+contains:[e.END_SAME_AS_BEGIN({begin:/(\w+)/,end:/(\w+)/,
+contains:[e.BACKSLASH_ESCAPE,c]})]}]},g="[0-9](_?[0-9])*",u={className:"number",
+relevance:0,variants:[{
+begin:`\\b([1-9](_?[0-9])*|0)(\\.(${g}))?([eE][+-]?(${g})|r)?i?\\b`},{
+begin:"\\b0[dD][0-9](_?[0-9])*r?i?\\b"},{begin:"\\b0[bB][0-1](_?[0-1])*r?i?\\b"
+},{begin:"\\b0[oO][0-7](_?[0-7])*r?i?\\b"},{
+begin:"\\b0[xX][0-9a-fA-F](_?[0-9a-fA-F])*r?i?\\b"},{
+begin:"\\b0(_?[0-7])+r?i?\\b"}]},b={variants:[{match:/\(\)/},{
+className:"params",begin:/\(/,end:/(?=\))/,excludeBegin:!0,endsParent:!0,
+keywords:r}]},m=[d,{variants:[{match:[/class\s+/,i,/\s+<\s+/,i]},{
+match:[/\b(class|module)\s+/,i]}],scope:{2:"title.class",
+4:"title.class.inherited"},keywords:r},{match:[/(include|extend)\s+/,i],scope:{
+2:"title.class"},keywords:r},{relevance:0,match:[i,/\.new[. (]/],scope:{
+1:"title.class"}},{relevance:0,match:/\b[A-Z][A-Z_0-9]+\b/,
+className:"variable.constant"},{relevance:0,match:a,scope:"title.class"},{
+match:[/def/,/\s+/,t],scope:{1:"keyword",3:"title.function"},contains:[b]},{
+begin:e.IDENT_RE+"::"},{className:"symbol",
+begin:e.UNDERSCORE_IDENT_RE+"(!|\\?)?:",relevance:0},{className:"symbol",
+begin:":(?!\\s)",contains:[d,{begin:t}],relevance:0},u,{className:"variable",
+begin:"(\\$\\W)|((\\$|@@?)(\\w+))(?=[^@$?])(?![A-Za-z])(?![@$?'])"},{
+className:"params",begin:/\|/,end:/\|/,excludeBegin:!0,excludeEnd:!0,
+relevance:0,keywords:r},{begin:"("+e.RE_STARTERS_RE+"|unless)\\s*",
+keywords:"unless",contains:[{className:"regexp",contains:[e.BACKSLASH_ESCAPE,c],
+illegal:/\n/,variants:[{begin:"/",end:"/[a-z]*"},{begin:/%r\{/,end:/\}[a-z]*/},{
+begin:"%r\\(",end:"\\)[a-z]*"},{begin:"%r!",end:"![a-z]*"},{begin:"%r\\[",
+end:"\\][a-z]*"}]}].concat(o,l),relevance:0}].concat(o,l)
+;c.contains=m,b.contains=m;const p=[{begin:/^\s*=>/,starts:{end:"$",contains:m}
+},{className:"meta.prompt",
+begin:"^([>?]>|[\\w#]+\\(\\w+\\):\\d+:\\d+[>*]|(\\w+-)?\\d+\\.\\d+\\.\\d+(p\\d+)?[^\\d][^>]+>)(?=[ ])",
+starts:{end:"$",keywords:r,contains:m}}];return l.unshift(o),{name:"Ruby",
+aliases:["rb","gemspec","podspec","thor","irb"],keywords:r,illegal:/\/\*/,
+contains:[e.SHEBANG({binary:"ruby"})].concat(p).concat(l).concat(m)}},
+grmr_rust:e=>{const n=e.regex,t={className:"title.function.invoke",relevance:0,
+begin:n.concat(/\b/,/(?!let|for|while|if|else|match\b)/,e.IDENT_RE,n.lookahead(/\s*\(/))
+},a="([ui](8|16|32|64|128|size)|f(32|64))?",i=["drop ","Copy","Send","Sized","Sync","Drop","Fn","FnMut","FnOnce","ToOwned","Clone","Debug","PartialEq","PartialOrd","Eq","Ord","AsRef","AsMut","Into","From","Default","Iterator","Extend","IntoIterator","DoubleEndedIterator","ExactSizeIterator","SliceConcatExt","ToString","assert!","assert_eq!","bitflags!","bytes!","cfg!","col!","concat!","concat_idents!","debug_assert!","debug_assert_eq!","env!","eprintln!","panic!","file!","format!","format_args!","include_bytes!","include_str!","line!","local_data_key!","module_path!","option_env!","print!","println!","select!","stringify!","try!","unimplemented!","unreachable!","vec!","write!","writeln!","macro_rules!","assert_ne!","debug_assert_ne!"],r=["i8","i16","i32","i64","i128","isize","u8","u16","u32","u64","u128","usize","f32","f64","str","char","bool","Box","Option","Result","String","Vec"]
+;return{name:"Rust",aliases:["rs"],keywords:{$pattern:e.IDENT_RE+"!?",type:r,
+keyword:["abstract","as","async","await","become","box","break","const","continue","crate","do","dyn","else","enum","extern","false","final","fn","for","if","impl","in","let","loop","macro","match","mod","move","mut","override","priv","pub","ref","return","self","Self","static","struct","super","trait","true","try","type","typeof","unsafe","unsized","use","virtual","where","while","yield"],
+literal:["true","false","Some","None","Ok","Err"],built_in:i},illegal:"</",
+contains:[e.C_LINE_COMMENT_MODE,e.COMMENT("/\\*","\\*/",{contains:["self"]
+}),e.inherit(e.QUOTE_STRING_MODE,{begin:/b?"/,illegal:null}),{
+className:"string",variants:[{begin:/b?r(#*)"(.|\n)*?"\1(?!#)/},{
+begin:/b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/}]},{className:"symbol",
+begin:/'[a-zA-Z_][a-zA-Z0-9_]*/},{className:"number",variants:[{
+begin:"\\b0b([01_]+)"+a},{begin:"\\b0o([0-7_]+)"+a},{
+begin:"\\b0x([A-Fa-f0-9_]+)"+a},{
+begin:"\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)"+a}],relevance:0},{
+begin:[/fn/,/\s+/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",
+3:"title.function"}},{className:"meta",begin:"#!?\\[",end:"\\]",contains:[{
+className:"string",begin:/"/,end:/"/}]},{
+begin:[/let/,/\s+/,/(?:mut\s+)?/,e.UNDERSCORE_IDENT_RE],className:{1:"keyword",
+3:"keyword",4:"variable"}},{
+begin:[/for/,/\s+/,e.UNDERSCORE_IDENT_RE,/\s+/,/in/],className:{1:"keyword",
+3:"variable",5:"keyword"}},{begin:[/type/,/\s+/,e.UNDERSCORE_IDENT_RE],
+className:{1:"keyword",3:"title.class"}},{
+begin:[/(?:trait|enum|struct|union|impl|for)/,/\s+/,e.UNDERSCORE_IDENT_RE],
+className:{1:"keyword",3:"title.class"}},{begin:e.IDENT_RE+"::",keywords:{
+keyword:"Self",built_in:i,type:r}},{className:"punctuation",begin:"->"},t]}},
+grmr_scss:e=>{const n=ie(e),t=le,a=oe,i="@[a-z-]+",r={className:"variable",
+begin:"(\\$[a-zA-Z-][a-zA-Z0-9_-]*)\\b",relevance:0};return{name:"SCSS",
+case_insensitive:!0,illegal:"[=/|']",
+contains:[e.C_LINE_COMMENT_MODE,e.C_BLOCK_COMMENT_MODE,n.CSS_NUMBER_MODE,{
+className:"selector-id",begin:"#[A-Za-z0-9_-]+",relevance:0},{
+className:"selector-class",begin:"\\.[A-Za-z0-9_-]+",relevance:0
+},n.ATTRIBUTE_SELECTOR_MODE,{className:"selector-tag",
+begin:"\\b("+re.join("|")+")\\b",relevance:0},{className:"selector-pseudo",
+begin:":("+a.join("|")+")"},{className:"selector-pseudo",
+begin:":(:)?("+t.join("|")+")"},r,{begin:/\(/,end:/\)/,
+contains:[n.CSS_NUMBER_MODE]},n.CSS_VARIABLE,{className:"attribute",
+begin:"\\b("+ce.join("|")+")\\b"},{
+begin:"\\b(whitespace|wait|w-resize|visible|vertical-text|vertical-ideographic|uppercase|upper-roman|upper-alpha|underline|transparent|top|thin|thick|text|text-top|text-bottom|tb-rl|table-header-group|table-footer-group|sw-resize|super|strict|static|square|solid|small-caps|separate|se-resize|scroll|s-resize|rtl|row-resize|ridge|right|repeat|repeat-y|repeat-x|relative|progress|pointer|overline|outside|outset|oblique|nowrap|not-allowed|normal|none|nw-resize|no-repeat|no-drop|newspaper|ne-resize|n-resize|move|middle|medium|ltr|lr-tb|lowercase|lower-roman|lower-alpha|loose|list-item|line|line-through|line-edge|lighter|left|keep-all|justify|italic|inter-word|inter-ideograph|inside|inset|inline|inline-block|inherit|inactive|ideograph-space|ideograph-parenthesis|ideograph-numeric|ideograph-alpha|horizontal|hidden|help|hand|groove|fixed|ellipsis|e-resize|double|dotted|distribute|distribute-space|distribute-letter|distribute-all-lines|disc|disabled|default|decimal|dashed|crosshair|collapse|col-resize|circle|char|center|capitalize|break-word|break-all|bottom|both|bolder|bold|block|bidi-override|below|baseline|auto|always|all-scroll|absolute|table|table-cell)\\b"
+},{begin:/:/,end:/[;}{]/,relevance:0,
+contains:[n.BLOCK_COMMENT,r,n.HEXCOLOR,n.CSS_NUMBER_MODE,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,n.IMPORTANT,n.FUNCTION_DISPATCH]
+},{begin:"@(page|font-face)",keywords:{$pattern:i,keyword:"@page @font-face"}},{
+begin:"@",end:"[{;]",returnBegin:!0,keywords:{$pattern:/[a-z-]+/,
+keyword:"and or not only",attribute:se.join(" ")},contains:[{begin:i,
+className:"keyword"},{begin:/[a-z-]+(?=:)/,className:"attribute"
+},r,e.QUOTE_STRING_MODE,e.APOS_STRING_MODE,n.HEXCOLOR,n.CSS_NUMBER_MODE]
+},n.FUNCTION_DISPATCH]}},grmr_shell:e=>({name:"Shell Session",
+aliases:["console","shellsession"],contains:[{className:"meta.prompt",
+begin:/^\s{0,3}[/~\w\d[\]()@-]*[>%$#][ ]?/,starts:{end:/[^\\](?=\s*$)/,
+subLanguage:"bash"}}]}),grmr_sql:e=>{
+const n=e.regex,t=e.COMMENT("--","$"),a=["true","false","unknown"],i=["bigint","binary","blob","boolean","char","character","clob","date","dec","decfloat","decimal","float","int","integer","interval","nchar","nclob","national","numeric","real","row","smallint","time","timestamp","varchar","varying","varbinary"],r=["abs","acos","array_agg","asin","atan","avg","cast","ceil","ceiling","coalesce","corr","cos","cosh","count","covar_pop","covar_samp","cume_dist","dense_rank","deref","element","exp","extract","first_value","floor","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","last_value","lead","listagg","ln","log","log10","lower","max","min","mod","nth_value","ntile","nullif","percent_rank","percentile_cont","percentile_disc","position","position_regex","power","rank","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","row_number","sin","sinh","sqrt","stddev_pop","stddev_samp","substring","substring_regex","sum","tan","tanh","translate","translate_regex","treat","trim","trim_array","unnest","upper","value_of","var_pop","var_samp","width_bucket"],s=["create table","insert into","primary key","foreign key","not null","alter table","add constraint","grouping sets","on overflow","character set","respect nulls","ignore nulls","nulls first","nulls last","depth first","breadth first"],o=r,l=["abs","acos","all","allocate","alter","and","any","are","array","array_agg","array_max_cardinality","as","asensitive","asin","asymmetric","at","atan","atomic","authorization","avg","begin","begin_frame","begin_partition","between","bigint","binary","blob","boolean","both","by","call","called","cardinality","cascaded","case","cast","ceil","ceiling","char","char_length","character","character_length","check","classifier","clob","close","coalesce","collate","collect","column","commit","condition","connect","constraint","contains","convert","copy","corr","corresponding","cos","cosh","count","covar_pop","covar_samp","create","cross","cube","cume_dist","current","current_catalog","current_date","current_default_transform_group","current_path","current_role","current_row","current_schema","current_time","current_timestamp","current_path","current_role","current_transform_group_for_type","current_user","cursor","cycle","date","day","deallocate","dec","decimal","decfloat","declare","default","define","delete","dense_rank","deref","describe","deterministic","disconnect","distinct","double","drop","dynamic","each","element","else","empty","end","end_frame","end_partition","end-exec","equals","escape","every","except","exec","execute","exists","exp","external","extract","false","fetch","filter","first_value","float","floor","for","foreign","frame_row","free","from","full","function","fusion","get","global","grant","group","grouping","groups","having","hold","hour","identity","in","indicator","initial","inner","inout","insensitive","insert","int","integer","intersect","intersection","interval","into","is","join","json_array","json_arrayagg","json_exists","json_object","json_objectagg","json_query","json_table","json_table_primitive","json_value","lag","language","large","last_value","lateral","lead","leading","left","like","like_regex","listagg","ln","local","localtime","localtimestamp","log","log10","lower","match","match_number","match_recognize","matches","max","member","merge","method","min","minute","mod","modifies","module","month","multiset","national","natural","nchar","nclob","new","no","none","normalize","not","nth_value","ntile","null","nullif","numeric","octet_length","occurrences_regex","of","offset","old","omit","on","one","only","open","or","order","out","outer","over","overlaps","overlay","parameter","partition","pattern","per","percent","percent_rank","percentile_cont","percentile_disc","period","portion","position","position_regex","power","precedes","precision","prepare","primary","procedure","ptf","range","rank","reads","real","recursive","ref","references","referencing","regr_avgx","regr_avgy","regr_count","regr_intercept","regr_r2","regr_slope","regr_sxx","regr_sxy","regr_syy","release","result","return","returns","revoke","right","rollback","rollup","row","row_number","rows","running","savepoint","scope","scroll","search","second","seek","select","sensitive","session_user","set","show","similar","sin","sinh","skip","smallint","some","specific","specifictype","sql","sqlexception","sqlstate","sqlwarning","sqrt","start","static","stddev_pop","stddev_samp","submultiset","subset","substring","substring_regex","succeeds","sum","symmetric","system","system_time","system_user","table","tablesample","tan","tanh","then","time","timestamp","timezone_hour","timezone_minute","to","trailing","translate","translate_regex","translation","treat","trigger","trim","trim_array","true","truncate","uescape","union","unique","unknown","unnest","update","upper","user","using","value","values","value_of","var_pop","var_samp","varbinary","varchar","varying","versioning","when","whenever","where","width_bucket","window","with","within","without","year","add","asc","collation","desc","final","first","last","view"].filter((e=>!r.includes(e))),c={
+begin:n.concat(/\b/,n.either(...o),/\s*\(/),relevance:0,keywords:{built_in:o}}
+;return{name:"SQL",case_insensitive:!0,illegal:/[{}]|<\//,keywords:{
+$pattern:/\b[\w\.]+/,keyword:((e,{exceptions:n,when:t}={})=>{const a=t
+;return n=n||[],e.map((e=>e.match(/\|\d+$/)||n.includes(e)?e:a(e)?e+"|0":e))
+})(l,{when:e=>e.length<3}),literal:a,type:i,
+built_in:["current_catalog","current_date","current_default_transform_group","current_path","current_role","current_schema","current_transform_group_for_type","current_user","session_user","system_time","system_user","current_time","localtime","current_timestamp","localtimestamp"]
+},contains:[{begin:n.either(...s),relevance:0,keywords:{$pattern:/[\w\.]+/,
+keyword:l.concat(s),literal:a,type:i}},{className:"type",
+begin:n.either("double precision","large object","with timezone","without timezone")
+},c,{className:"variable",begin:/@[a-z0-9][a-z0-9_]*/},{className:"string",
+variants:[{begin:/'/,end:/'/,contains:[{begin:/''/}]}]},{begin:/"/,end:/"/,
+contains:[{begin:/""/}]},e.C_NUMBER_MODE,e.C_BLOCK_COMMENT_MODE,t,{
+className:"operator",begin:/[-+*/=%^~]|&&?|\|\|?|!=?|<(?:=>?|<|>)?|>[>=]?/,
+relevance:0}]}},grmr_swift:e=>{const n={match:/\s+/,relevance:0
+},t=e.COMMENT("/\\*","\\*/",{contains:["self"]}),a=[e.C_LINE_COMMENT_MODE,t],i={
+match:[/\./,m(...xe,...Me)],className:{2:"keyword"}},r={match:b(/\./,m(...Ae)),
+relevance:0},s=Ae.filter((e=>"string"==typeof e)).concat(["_|0"]),o={variants:[{
+className:"keyword",
+match:m(...Ae.filter((e=>"string"!=typeof e)).concat(Se).map(ke),...Me)}]},l={
+$pattern:m(/\b\w+/,/#\w+/),keyword:s.concat(Re),literal:Ce},c=[i,r,o],g=[{
+match:b(/\./,m(...De)),relevance:0},{className:"built_in",
+match:b(/\b/,m(...De),/(?=\()/)}],u={match:/->/,relevance:0},p=[u,{
+className:"operator",relevance:0,variants:[{match:Be},{match:`\\.(\\.|${Le})+`}]
+}],_="([0-9]_*)+",h="([0-9a-fA-F]_*)+",f={className:"number",relevance:0,
+variants:[{match:`\\b(${_})(\\.(${_}))?([eE][+-]?(${_}))?\\b`},{
+match:`\\b0x(${h})(\\.(${h}))?([pP][+-]?(${_}))?\\b`},{match:/\b0o([0-7]_*)+\b/
+},{match:/\b0b([01]_*)+\b/}]},E=(e="")=>({className:"subst",variants:[{
+match:b(/\\/,e,/[0\\tnr"']/)},{match:b(/\\/,e,/u\{[0-9a-fA-F]{1,8}\}/)}]
+}),y=(e="")=>({className:"subst",match:b(/\\/,e,/[\t ]*(?:[\r\n]|\r\n)/)
+}),N=(e="")=>({className:"subst",label:"interpol",begin:b(/\\/,e,/\(/),end:/\)/
+}),w=(e="")=>({begin:b(e,/"""/),end:b(/"""/,e),contains:[E(e),y(e),N(e)]
+}),v=(e="")=>({begin:b(e,/"/),end:b(/"/,e),contains:[E(e),N(e)]}),O={
+className:"string",
+variants:[w(),w("#"),w("##"),w("###"),v(),v("#"),v("##"),v("###")]
+},k=[e.BACKSLASH_ESCAPE,{begin:/\[/,end:/\]/,relevance:0,
+contains:[e.BACKSLASH_ESCAPE]}],x={begin:/\/[^\s](?=[^/\n]*\/)/,end:/\//,
+contains:k},M=e=>{const n=b(e,/\//),t=b(/\//,e);return{begin:n,end:t,
+contains:[...k,{scope:"comment",begin:`#(?!.*${t})`,end:/$/}]}},S={
+scope:"regexp",variants:[M("###"),M("##"),M("#"),x]},A={match:b(/`/,Fe,/`/)
+},C=[A,{className:"variable",match:/\$\d+/},{className:"variable",
+match:`\\${ze}+`}],T=[{match:/(@|#(un)?)available/,scope:"keyword",starts:{
+contains:[{begin:/\(/,end:/\)/,keywords:Pe,contains:[...p,f,O]}]}},{
+scope:"keyword",match:b(/@/,m(...je))},{scope:"meta",match:b(/@/,Fe)}],R={
+match:d(/\b[A-Z]/),relevance:0,contains:[{className:"type",
+match:b(/(AV|CA|CF|CG|CI|CL|CM|CN|CT|MK|MP|MTK|MTL|NS|SCN|SK|UI|WK|XC)/,ze,"+")
+},{className:"type",match:Ue,relevance:0},{match:/[?!]+/,relevance:0},{
+match:/\.\.\./,relevance:0},{match:b(/\s+&\s+/,d(Ue)),relevance:0}]},D={
+begin:/</,end:/>/,keywords:l,contains:[...a,...c,...T,u,R]};R.contains.push(D)
+;const I={begin:/\(/,end:/\)/,relevance:0,keywords:l,contains:["self",{
+match:b(Fe,/\s*:/),keywords:"_|0",relevance:0
+},...a,S,...c,...g,...p,f,O,...C,...T,R]},L={begin:/</,end:/>/,
+keywords:"repeat each",contains:[...a,R]},B={begin:/\(/,end:/\)/,keywords:l,
+contains:[{begin:m(d(b(Fe,/\s*:/)),d(b(Fe,/\s+/,Fe,/\s*:/))),end:/:/,
+relevance:0,contains:[{className:"keyword",match:/\b_\b/},{className:"params",
+match:Fe}]},...a,...c,...p,f,O,...T,R,I],endsParent:!0,illegal:/["']/},$={
+match:[/(func|macro)/,/\s+/,m(A.match,Fe,Be)],className:{1:"keyword",
+3:"title.function"},contains:[L,B,n],illegal:[/\[/,/%/]},z={
+match:[/\b(?:subscript|init[?!]?)/,/\s*(?=[<(])/],className:{1:"keyword"},
+contains:[L,B,n],illegal:/\[|%/},F={match:[/operator/,/\s+/,Be],className:{
+1:"keyword",3:"title"}},U={begin:[/precedencegroup/,/\s+/,Ue],className:{
+1:"keyword",3:"title"},contains:[R],keywords:[...Te,...Ce],end:/}/}
+;for(const e of O.variants){const n=e.contains.find((e=>"interpol"===e.label))
+;n.keywords=l;const t=[...c,...g,...p,f,O,...C];n.contains=[...t,{begin:/\(/,
+end:/\)/,contains:["self",...t]}]}return{name:"Swift",keywords:l,
+contains:[...a,$,z,{beginKeywords:"struct protocol class extension enum actor",
+end:"\\{",excludeEnd:!0,keywords:l,contains:[e.inherit(e.TITLE_MODE,{
+className:"title.class",begin:/[A-Za-z$_][\u00C0-\u02B80-9A-Za-z$_]*/}),...c]
+},F,U,{beginKeywords:"import",end:/$/,contains:[...a],relevance:0
+},S,...c,...g,...p,f,O,...C,...T,R,I]}},grmr_typescript:e=>{
+const n=Oe(e),t=_e,a=["any","void","number","boolean","string","object","never","symbol","bigint","unknown"],i={
+beginKeywords:"namespace",end:/\{/,excludeEnd:!0,
+contains:[n.exports.CLASS_REFERENCE]},r={beginKeywords:"interface",end:/\{/,
+excludeEnd:!0,keywords:{keyword:"interface extends",built_in:a},
+contains:[n.exports.CLASS_REFERENCE]},s={$pattern:_e,
+keyword:he.concat(["type","namespace","interface","public","private","protected","implements","declare","abstract","readonly","enum","override"]),
+literal:fe,built_in:ve.concat(a),"variable.language":we},o={className:"meta",
+begin:"@"+t},l=(e,n,t)=>{const a=e.contains.findIndex((e=>e.label===n))
+;if(-1===a)throw Error("can not find mode to replace");e.contains.splice(a,1,t)}
+;return Object.assign(n.keywords,s),
+n.exports.PARAMS_CONTAINS.push(o),n.contains=n.contains.concat([o,i,r]),
+l(n,"shebang",e.SHEBANG()),l(n,"use_strict",{className:"meta",relevance:10,
+begin:/^\s*['"]use strict['"]/
+}),n.contains.find((e=>"func.def"===e.label)).relevance=0,Object.assign(n,{
+name:"TypeScript",aliases:["ts","tsx","mts","cts"]}),n},grmr_vbnet:e=>{
+const n=e.regex,t=/\d{1,2}\/\d{1,2}\/\d{4}/,a=/\d{4}-\d{1,2}-\d{1,2}/,i=/(\d|1[012])(:\d+){0,2} *(AM|PM)/,r=/\d{1,2}(:\d{1,2}){1,2}/,s={
+className:"literal",variants:[{begin:n.concat(/# */,n.either(a,t),/ *#/)},{
+begin:n.concat(/# */,r,/ *#/)},{begin:n.concat(/# */,i,/ *#/)},{
+begin:n.concat(/# */,n.either(a,t),/ +/,n.either(i,r),/ *#/)}]
+},o=e.COMMENT(/'''/,/$/,{contains:[{className:"doctag",begin:/<\/?/,end:/>/}]
+}),l=e.COMMENT(null,/$/,{variants:[{begin:/'/},{begin:/([\t ]|^)REM(?=\s)/}]})
+;return{name:"Visual Basic .NET",aliases:["vb"],case_insensitive:!0,
+classNameAliases:{label:"symbol"},keywords:{
+keyword:"addhandler alias aggregate ansi as async assembly auto binary by byref byval call case catch class compare const continue custom declare default delegate dim distinct do each equals else elseif end enum erase error event exit explicit finally for friend from function get global goto group handles if implements imports in inherits interface into iterator join key let lib loop me mid module mustinherit mustoverride mybase myclass namespace narrowing new next notinheritable notoverridable of off on operator option optional order overloads overridable overrides paramarray partial preserve private property protected public raiseevent readonly redim removehandler resume return select set shadows shared skip static step stop structure strict sub synclock take text then throw to try unicode until using when where while widening with withevents writeonly yield",
+built_in:"addressof and andalso await directcast gettype getxmlnamespace is isfalse isnot istrue like mod nameof new not or orelse trycast typeof xor cbool cbyte cchar cdate cdbl cdec cint clng cobj csbyte cshort csng cstr cuint culng cushort",
+type:"boolean byte char date decimal double integer long object sbyte short single string uinteger ulong ushort",
+literal:"true false nothing"},
+illegal:"//|\\{|\\}|endif|gosub|variant|wend|^\\$ ",contains:[{
+className:"string",begin:/"(""|[^/n])"C\b/},{className:"string",begin:/"/,
+end:/"/,illegal:/\n/,contains:[{begin:/""/}]},s,{className:"number",relevance:0,
+variants:[{begin:/\b\d[\d_]*((\.[\d_]+(E[+-]?[\d_]+)?)|(E[+-]?[\d_]+))[RFD@!#]?/
+},{begin:/\b\d[\d_]*((U?[SIL])|[%&])?/},{begin:/&H[\dA-F_]+((U?[SIL])|[%&])?/},{
+begin:/&O[0-7_]+((U?[SIL])|[%&])?/},{begin:/&B[01_]+((U?[SIL])|[%&])?/}]},{
+className:"label",begin:/^\w+:/},o,l,{className:"meta",
+begin:/[\t ]*#(const|disable|else|elseif|enable|end|externalsource|if|region)\b/,
+end:/$/,keywords:{
+keyword:"const disable else elseif enable end externalsource if region then"},
+contains:[l]}]}},grmr_wasm:e=>{e.regex;const n=e.COMMENT(/\(;/,/;\)/)
+;return n.contains.push("self"),{name:"WebAssembly",keywords:{$pattern:/[\w.]+/,
+keyword:["anyfunc","block","br","br_if","br_table","call","call_indirect","data","drop","elem","else","end","export","func","global.get","global.set","local.get","local.set","local.tee","get_global","get_local","global","if","import","local","loop","memory","memory.grow","memory.size","module","mut","nop","offset","param","result","return","select","set_global","set_local","start","table","tee_local","then","type","unreachable"]
+},contains:[e.COMMENT(/;;/,/$/),n,{match:[/(?:offset|align)/,/\s*/,/=/],
+className:{1:"keyword",3:"operator"}},{className:"variable",begin:/\$[\w_]+/},{
+match:/(\((?!;)|\))+/,className:"punctuation",relevance:0},{
+begin:[/(?:func|call|call_indirect)/,/\s+/,/\$[^\s)]+/],className:{1:"keyword",
+3:"title.function"}},e.QUOTE_STRING_MODE,{match:/(i32|i64|f32|f64)(?!\.)/,
+className:"type"},{className:"keyword",
+match:/\b(f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|nearest|neg?|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|store(?:8|16|32)?|sqrt|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))\b/
+},{className:"number",relevance:0,
+match:/[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/
+}]}},grmr_xml:e=>{
+const n=e.regex,t=n.concat(/[\p{L}_]/u,n.optional(/[\p{L}0-9_.-]*:/u),/[\p{L}0-9_.-]*/u),a={
+className:"symbol",begin:/&[a-z]+;|&#[0-9]+;|&#x[a-f0-9]+;/},i={begin:/\s/,
+contains:[{className:"keyword",begin:/#?[a-z_][a-z1-9_-]+/,illegal:/\n/}]
+},r=e.inherit(i,{begin:/\(/,end:/\)/}),s=e.inherit(e.APOS_STRING_MODE,{
+className:"string"}),o=e.inherit(e.QUOTE_STRING_MODE,{className:"string"}),l={
+endsWithParent:!0,illegal:/</,relevance:0,contains:[{className:"attr",
+begin:/[\p{L}0-9._:-]+/u,relevance:0},{begin:/=\s*/,relevance:0,contains:[{
+className:"string",endsParent:!0,variants:[{begin:/"/,end:/"/,contains:[a]},{
+begin:/'/,end:/'/,contains:[a]},{begin:/[^\s"'=<>`]+/}]}]}]};return{
+name:"HTML, XML",
+aliases:["html","xhtml","rss","atom","xjb","xsd","xsl","plist","wsf","svg"],
+case_insensitive:!0,unicodeRegex:!0,contains:[{className:"meta",begin:/<![a-z]/,
+end:/>/,relevance:10,contains:[i,o,s,r,{begin:/\[/,end:/\]/,contains:[{
+className:"meta",begin:/<![a-z]/,end:/>/,contains:[i,r,o,s]}]}]
+},e.COMMENT(/<!--/,/-->/,{relevance:10}),{begin:/<!\[CDATA\[/,end:/\]\]>/,
+relevance:10},a,{className:"meta",end:/\?>/,variants:[{begin:/<\?xml/,
+relevance:10,contains:[o]},{begin:/<\?[a-z][a-z0-9]+/}]},{className:"tag",
+begin:/<style(?=\s|>)/,end:/>/,keywords:{name:"style"},contains:[l],starts:{
+end:/<\/style>/,returnEnd:!0,subLanguage:["css","xml"]}},{className:"tag",
+begin:/<script(?=\s|>)/,end:/>/,keywords:{name:"script"},contains:[l],starts:{
+end:/<\/script>/,returnEnd:!0,subLanguage:["javascript","handlebars","xml"]}},{
+className:"tag",begin:/<>|<\/>/},{className:"tag",
+begin:n.concat(/</,n.lookahead(n.concat(t,n.either(/\/>/,/>/,/\s/)))),
+end:/\/?>/,contains:[{className:"name",begin:t,relevance:0,starts:l}]},{
+className:"tag",begin:n.concat(/<\//,n.lookahead(n.concat(t,/>/))),contains:[{
+className:"name",begin:t,relevance:0},{begin:/>/,relevance:0,endsParent:!0}]}]}
+},grmr_yaml:e=>{
+const n="true false yes no null",t="[\\w#;/?:@&=+$,.~*'()[\\]]+",a={
+className:"string",relevance:0,variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/
+},{begin:/\S+/}],contains:[e.BACKSLASH_ESCAPE,{className:"template-variable",
+variants:[{begin:/\{\{/,end:/\}\}/},{begin:/%\{/,end:/\}/}]}]},i=e.inherit(a,{
+variants:[{begin:/'/,end:/'/},{begin:/"/,end:/"/},{begin:/[^\s,{}[\]]+/}]}),r={
+end:",",endsWithParent:!0,excludeEnd:!0,keywords:n,relevance:0},s={begin:/\{/,
+end:/\}/,contains:[r],illegal:"\\n",relevance:0},o={begin:"\\[",end:"\\]",
+contains:[r],illegal:"\\n",relevance:0},l=[{className:"attr",variants:[{
+begin:"\\w[\\w :\\/.-]*:(?=[ \t]|$)"},{begin:'"\\w[\\w :\\/.-]*":(?=[ \t]|$)'},{
+begin:"'\\w[\\w :\\/.-]*':(?=[ \t]|$)"}]},{className:"meta",begin:"^---\\s*$",
+relevance:10},{className:"string",
+begin:"[\\|>]([1-9]?[+-])?[ ]*\\n( +)[^ ][^\\n]*\\n(\\2[^\\n]+\\n?)*"},{
+begin:"<%[%=-]?",end:"[%-]?%>",subLanguage:"ruby",excludeBegin:!0,excludeEnd:!0,
+relevance:0},{className:"type",begin:"!\\w+!"+t},{className:"type",
+begin:"!<"+t+">"},{className:"type",begin:"!"+t},{className:"type",begin:"!!"+t
+},{className:"meta",begin:"&"+e.UNDERSCORE_IDENT_RE+"$"},{className:"meta",
+begin:"\\*"+e.UNDERSCORE_IDENT_RE+"$"},{className:"bullet",begin:"-(?=[ ]|$)",
+relevance:0},e.HASH_COMMENT_MODE,{beginKeywords:n,keywords:{literal:n}},{
+className:"number",
+begin:"\\b[0-9]{4}(-[0-9][0-9]){0,2}([Tt \\t][0-9][0-9]?(:[0-9][0-9]){2})?(\\.[0-9]*)?([ \\t])*(Z|[-+][0-9][0-9]?(:[0-9][0-9])?)?\\b"
+},{className:"number",begin:e.C_NUMBER_RE+"\\b",relevance:0},s,o,a],c=[...l]
+;return c.pop(),c.push(i),r.contains=c,{name:"YAML",case_insensitive:!0,
+aliases:["yml"],contains:l}}});const He=ae;for(const e of Object.keys(Ke)){
+const n=e.replace("grmr_","").replace("_","-");He.registerLanguage(n,Ke[e])}
+return He}()
+;"object"==typeof exports&&"undefined"!=typeof module&&(module.exports=hljs);</script>
+
+  <!-- Main application code -->
+  <script>
+    (function() {
+      'use strict';
+
+      // ============================================================
+      // DATA LOADING
+      // ============================================================
+
+      const base64 = document.getElementById('session-data').textContent;
+      const binary = atob(base64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+      }
+      const data = JSON.parse(new TextDecoder('utf-8').decode(bytes));
+      const { header, entries, leafId: defaultLeafId, systemPrompt, tools, renderedTools } = data;
+
+      // ============================================================
+      // URL PARAMETER HANDLING
+      // ============================================================
+
+      // Parse URL parameters for deep linking: leafId and targetId
+      // Check for injected params (when loaded in iframe via srcdoc) or use window.location
+      const injectedParams = document.querySelector('meta[name="pi-url-params"]');
+      const searchString = injectedParams ? injectedParams.content : window.location.search.substring(1);
+      const urlParams = new URLSearchParams(searchString);
+      const urlLeafId = urlParams.get('leafId');
+      const urlTargetId = urlParams.get('targetId');
+      // Use URL leafId if provided, otherwise fall back to session default
+      const leafId = urlLeafId || defaultLeafId;
+
+      // ============================================================
+      // DATA STRUCTURES
+      // ============================================================
+
+      // Entry lookup by ID
+      const byId = new Map();
+      for (const entry of entries) {
+        byId.set(entry.id, entry);
+      }
+
+      // Tool call lookup (toolCallId -> {name, arguments})
+      const toolCallMap = new Map();
+      for (const entry of entries) {
+        if (entry.type === 'message' && entry.message.role === 'assistant') {
+          const content = entry.message.content;
+          if (Array.isArray(content)) {
+            for (const block of content) {
+              if (block.type === 'toolCall') {
+                toolCallMap.set(block.id, { name: block.name, arguments: block.arguments });
+              }
+            }
+          }
+        }
+      }
+
+      // Label lookup (entryId -> label string)
+      // Labels are stored in 'label' entries that reference their target via targetId
+      const labelMap = new Map();
+      for (const entry of entries) {
+        if (entry.type === 'label' && entry.targetId && entry.label) {
+          labelMap.set(entry.targetId, entry.label);
+        }
+      }
+
+      // ============================================================
+      // TREE DATA PREPARATION (no DOM, pure data)
+      // ============================================================
+
+      /**
+       * Build tree structure from flat entries.
+       * Returns array of root nodes, each with { entry, children, label }.
+       */
+      function buildTree() {
+        const nodeMap = new Map();
+        const roots = [];
+
+        // Create nodes
+        for (const entry of entries) {
+          nodeMap.set(entry.id, {
+            entry,
+            children: [],
+            label: labelMap.get(entry.id)
+          });
+        }
+
+        // Build parent-child relationships
+        for (const entry of entries) {
+          const node = nodeMap.get(entry.id);
+          if (entry.parentId === null || entry.parentId === undefined || entry.parentId === entry.id) {
+            roots.push(node);
+          } else {
+            const parent = nodeMap.get(entry.parentId);
+            if (parent) {
+              parent.children.push(node);
+            } else {
+              roots.push(node);
+            }
+          }
+        }
+
+        // Sort children by timestamp
+        function sortChildren(node) {
+          node.children.sort((a, b) =>
+            new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime()
+          );
+          node.children.forEach(sortChildren);
+        }
+        roots.forEach(sortChildren);
+
+        return roots;
+      }
+
+      /**
+       * Build set of entry IDs on path from root to target.
+       */
+      function buildActivePathIds(targetId) {
+        const ids = new Set();
+        let current = byId.get(targetId);
+        while (current) {
+          ids.add(current.id);
+          // Stop if no parent or self-referencing (root)
+          if (!current.parentId || current.parentId === current.id) {
+            break;
+          }
+          current = byId.get(current.parentId);
+        }
+        return ids;
+      }
+
+      /**
+       * Get array of entries from root to target (the conversation path).
+       */
+      function getPath(targetId) {
+        const path = [];
+        let current = byId.get(targetId);
+        while (current) {
+          path.unshift(current);
+          // Stop if no parent or self-referencing (root)
+          if (!current.parentId || current.parentId === current.id) {
+            break;
+          }
+          current = byId.get(current.parentId);
+        }
+        return path;
+      }
+
+      // Tree node lookup for finding leaves
+      let treeNodeMap = null;
+
+      /**
+       * Find the newest leaf node reachable from a given node.
+       * This allows clicking any node in a branch to show the full branch.
+       * Children are sorted by timestamp, so the newest is always last.
+       */
+      function findNewestLeaf(nodeId) {
+        // Build tree node map lazily
+        if (!treeNodeMap) {
+          treeNodeMap = new Map();
+          const tree = buildTree();
+          function mapNodes(node) {
+            treeNodeMap.set(node.entry.id, node);
+            node.children.forEach(mapNodes);
+          }
+          tree.forEach(mapNodes);
+        }
+
+        const node = treeNodeMap.get(nodeId);
+        if (!node) return nodeId;
+
+        // Follow the newest (last) child at each level
+        let current = node;
+        while (current.children.length > 0) {
+          current = current.children[current.children.length - 1];
+        }
+        return current.entry.id;
+      }
+
+      /**
+       * Flatten tree into list with indentation and connector info.
+       * Returns array of { node, indent, showConnector, isLast, gutters, isVirtualRootChild, multipleRoots }.
+       * Matches tree-selector.ts logic exactly.
+       */
+      function flattenTree(roots, activePathIds) {
+        const result = [];
+        const multipleRoots = roots.length > 1;
+
+        // Mark which subtrees contain the active leaf
+        const containsActive = new Map();
+        function markActive(node) {
+          let has = activePathIds.has(node.entry.id);
+          for (const child of node.children) {
+            if (markActive(child)) has = true;
+          }
+          containsActive.set(node, has);
+          return has;
+        }
+        roots.forEach(markActive);
+
+        // Stack: [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild]
+        const stack = [];
+
+        // Add roots (prioritize branch containing active leaf)
+        const orderedRoots = [...roots].sort((a, b) =>
+          Number(containsActive.get(b)) - Number(containsActive.get(a))
+        );
+        for (let i = orderedRoots.length - 1; i >= 0; i--) {
+          const isLast = i === orderedRoots.length - 1;
+          stack.push([orderedRoots[i], multipleRoots ? 1 : 0, multipleRoots, multipleRoots, isLast, [], multipleRoots]);
+        }
+
+        while (stack.length > 0) {
+          const [node, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+
+          result.push({ node, indent, showConnector, isLast, gutters, isVirtualRootChild, multipleRoots });
+
+          const children = node.children;
+          const multipleChildren = children.length > 1;
+
+          // Order children (active branch first)
+          const orderedChildren = [...children].sort((a, b) =>
+            Number(containsActive.get(b)) - Number(containsActive.get(a))
+          );
+
+          // Calculate child indent (matches tree-selector.ts)
+          let childIndent;
+          if (multipleChildren) {
+            // Parent branches: children get +1
+            childIndent = indent + 1;
+          } else if (justBranched && indent > 0) {
+            // First generation after a branch: +1 for visual grouping
+            childIndent = indent + 1;
+          } else {
+            // Single-child chain: stay flat
+            childIndent = indent;
+          }
+
+          // Build gutters for children
+          const connectorDisplayed = showConnector && !isVirtualRootChild;
+          const currentDisplayIndent = multipleRoots ? Math.max(0, indent - 1) : indent;
+          const connectorPosition = Math.max(0, currentDisplayIndent - 1);
+          const childGutters = connectorDisplayed
+            ? [...gutters, { position: connectorPosition, show: !isLast }]
+            : gutters;
+
+          // Add children in reverse order for stack
+          for (let i = orderedChildren.length - 1; i >= 0; i--) {
+            const childIsLast = i === orderedChildren.length - 1;
+            stack.push([orderedChildren[i], childIndent, multipleChildren, multipleChildren, childIsLast, childGutters, false]);
+          }
+        }
+
+        return result;
+      }
+
+      /**
+       * Build ASCII prefix string for tree node.
+       */
+      function buildTreePrefix(flatNode) {
+        const { indent, showConnector, isLast, gutters, isVirtualRootChild, multipleRoots } = flatNode;
+        const displayIndent = multipleRoots ? Math.max(0, indent - 1) : indent;
+        const connector = showConnector && !isVirtualRootChild ? (isLast ? '└─ ' : '├─ ') : '';
+        const connectorPosition = connector ? displayIndent - 1 : -1;
+
+        const totalChars = displayIndent * 3;
+        const prefixChars = [];
+        for (let i = 0; i < totalChars; i++) {
+          const level = Math.floor(i / 3);
+          const posInLevel = i % 3;
+
+          const gutter = gutters.find(g => g.position === level);
+          if (gutter) {
+            prefixChars.push(posInLevel === 0 ? (gutter.show ? '│' : ' ') : ' ');
+          } else if (connector && level === connectorPosition) {
+            if (posInLevel === 0) {
+              prefixChars.push(isLast ? '└' : '├');
+            } else if (posInLevel === 1) {
+              prefixChars.push('─');
+            } else {
+              prefixChars.push(' ');
+            }
+          } else {
+            prefixChars.push(' ');
+          }
+        }
+        return prefixChars.join('');
+      }
+
+      // ============================================================
+      // FILTERING (pure data)
+      // ============================================================
+
+      let filterMode = 'default';
+      let searchQuery = '';
+
+      function hasTextContent(content) {
+        if (typeof content === 'string') return content.trim().length > 0;
+        if (Array.isArray(content)) {
+          for (const c of content) {
+            if (c.type === 'text' && c.text && c.text.trim().length > 0) return true;
+          }
+        }
+        return false;
+      }
+
+      function extractContent(content) {
+        if (typeof content === 'string') return content;
+        if (Array.isArray(content)) {
+          return content
+            .filter(c => c.type === 'text' && c.text)
+            .map(c => c.text)
+            .join('');
+        }
+        return '';
+      }
+
+      /**
+       * Parse a skill block from message text.
+       * Returns null if the text doesn't contain a skill block.
+       * Matches the format: <skill name="..." location="...">\n...\n</skill>\n\nuser message
+       */
+      function parseSkillBlock(text) {
+        const match = text.match(/^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/);
+        if (!match) return null;
+        return {
+          name: match[1],
+          location: match[2],
+          content: match[3],
+          userMessage: match[4]?.trim() || undefined,
+        };
+      }
+
+      function getSearchableText(entry, label) {
+        const parts = [];
+        if (label) parts.push(label);
+
+        switch (entry.type) {
+          case 'message': {
+            const msg = entry.message;
+            parts.push(msg.role);
+            if (msg.content) parts.push(extractContent(msg.content));
+            if (msg.role === 'bashExecution' && msg.command) parts.push(msg.command);
+            break;
+          }
+          case 'custom_message':
+            parts.push(entry.customType);
+            parts.push(typeof entry.content === 'string' ? entry.content : extractContent(entry.content));
+            break;
+          case 'compaction':
+            parts.push('compaction');
+            break;
+          case 'branch_summary':
+            parts.push('branch summary', entry.summary);
+            break;
+          case 'model_change':
+            parts.push('model', entry.modelId);
+            break;
+          case 'thinking_level_change':
+            parts.push('thinking', entry.thinkingLevel);
+            break;
+        }
+
+        return parts.join(' ').toLowerCase();
+      }
+
+      /**
+       * Filter flat nodes based on current filterMode and searchQuery.
+       */
+      function filterNodes(flatNodes, currentLeafId) {
+        const searchTokens = searchQuery.toLowerCase().split(/\s+/).filter(Boolean);
+
+        const filtered = flatNodes.filter(flatNode => {
+          const entry = flatNode.node.entry;
+          const label = flatNode.node.label;
+          const isCurrentLeaf = entry.id === currentLeafId;
+
+          // Always show current leaf
+          if (isCurrentLeaf) return true;
+
+          // Hide assistant messages with only tool calls (no text) unless error/aborted
+          if (entry.type === 'message' && entry.message.role === 'assistant') {
+            const msg = entry.message;
+            const hasText = hasTextContent(msg.content);
+            const isErrorOrAborted = msg.stopReason && msg.stopReason !== 'stop' && msg.stopReason !== 'toolUse';
+            if (!hasText && !isErrorOrAborted) return false;
+          }
+
+          // Apply filter mode
+          const isSettingsEntry = ['label', 'custom', 'model_change', 'thinking_level_change'].includes(entry.type);
+          let passesFilter = true;
+
+          switch (filterMode) {
+            case 'user-only':
+              passesFilter = entry.type === 'message' && entry.message.role === 'user';
+              break;
+            case 'no-tools':
+              passesFilter = !isSettingsEntry && !(entry.type === 'message' && entry.message.role === 'toolResult');
+              break;
+            case 'labeled-only':
+              passesFilter = label !== undefined;
+              break;
+            case 'all':
+              passesFilter = true;
+              break;
+            default: // 'default'
+              passesFilter = !isSettingsEntry;
+              break;
+          }
+
+          if (!passesFilter) return false;
+
+          // Apply search filter
+          if (searchTokens.length > 0) {
+            const nodeText = getSearchableText(entry, label);
+            if (!searchTokens.every(t => nodeText.includes(t))) return false;
+          }
+
+          return true;
+        });
+
+        // Recalculate visual structure based on visible tree
+        recalculateVisualStructure(filtered, flatNodes);
+
+        return filtered;
+      }
+
+      /**
+       * Recompute indentation/connectors for the filtered view
+       *
+       * Filtering can hide intermediate entries; descendants attach to the nearest visible ancestor.
+       * Keep indentation semantics aligned with flattenTree() so single-child chains don't drift right.
+       */
+      function recalculateVisualStructure(filteredNodes, allFlatNodes) {
+        if (filteredNodes.length === 0) return;
+
+        const visibleIds = new Set(filteredNodes.map(n => n.node.entry.id));
+
+        // Build entry map for parent lookup (using full tree)
+        const entryMap = new Map();
+        for (const flatNode of allFlatNodes) {
+          entryMap.set(flatNode.node.entry.id, flatNode);
+        }
+
+        // Find nearest visible ancestor for a node
+        function findVisibleAncestor(nodeId) {
+          let currentId = entryMap.get(nodeId)?.node.entry.parentId;
+          while (currentId != null) {
+            if (visibleIds.has(currentId)) {
+              return currentId;
+            }
+            currentId = entryMap.get(currentId)?.node.entry.parentId;
+          }
+          return null;
+        }
+
+        // Build visible tree structure
+        const visibleParent = new Map();
+        const visibleChildren = new Map();
+        visibleChildren.set(null, []); // root-level nodes
+
+        for (const flatNode of filteredNodes) {
+          const nodeId = flatNode.node.entry.id;
+          const ancestorId = findVisibleAncestor(nodeId);
+          visibleParent.set(nodeId, ancestorId);
+
+          if (!visibleChildren.has(ancestorId)) {
+            visibleChildren.set(ancestorId, []);
+          }
+          visibleChildren.get(ancestorId).push(nodeId);
+        }
+
+        // Update multipleRoots based on visible roots
+        const visibleRootIds = visibleChildren.get(null);
+        const multipleRoots = visibleRootIds.length > 1;
+
+        // Build a map for quick lookup: nodeId → FlatNode
+        const filteredNodeMap = new Map();
+        for (const flatNode of filteredNodes) {
+          filteredNodeMap.set(flatNode.node.entry.id, flatNode);
+        }
+
+        // DFS traversal of visible tree, applying same indentation rules as flattenTree()
+        // Stack items: [nodeId, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild]
+        const stack = [];
+
+        // Add visible roots in reverse order (to process in forward order via stack)
+        for (let i = visibleRootIds.length - 1; i >= 0; i--) {
+          const isLast = i === visibleRootIds.length - 1;
+          stack.push([
+            visibleRootIds[i],
+            multipleRoots ? 1 : 0,
+            multipleRoots,
+            multipleRoots,
+            isLast,
+            [],
+            multipleRoots
+          ]);
+        }
+
+        while (stack.length > 0) {
+          const [nodeId, indent, justBranched, showConnector, isLast, gutters, isVirtualRootChild] = stack.pop();
+
+          const flatNode = filteredNodeMap.get(nodeId);
+          if (!flatNode) continue;
+
+          // Update this node's visual properties
+          flatNode.indent = indent;
+          flatNode.showConnector = showConnector;
+          flatNode.isLast = isLast;
+          flatNode.gutters = gutters;
+          flatNode.isVirtualRootChild = isVirtualRootChild;
+          flatNode.multipleRoots = multipleRoots;
+
+          // Get visible children of this node
+          const children = visibleChildren.get(nodeId) || [];
+          const multipleChildren = children.length > 1;
+
+          // Calculate child indent using same rules as flattenTree():
+          // - Parent branches (multiple children): children get +1
+          // - Just branched and indent > 0: children get +1 for visual grouping
+          // - Single-child chain: stay flat
+          let childIndent;
+          if (multipleChildren) {
+            childIndent = indent + 1;
+          } else if (justBranched && indent > 0) {
+            childIndent = indent + 1;
+          } else {
+            childIndent = indent;
+          }
+
+          // Build gutters for children (same logic as flattenTree)
+          const connectorDisplayed = showConnector && !isVirtualRootChild;
+          const currentDisplayIndent = multipleRoots ? Math.max(0, indent - 1) : indent;
+          const connectorPosition = Math.max(0, currentDisplayIndent - 1);
+          const childGutters = connectorDisplayed
+            ? [...gutters, { position: connectorPosition, show: !isLast }]
+            : gutters;
+
+          // Add children in reverse order (to process in forward order via stack)
+          for (let i = children.length - 1; i >= 0; i--) {
+            const childIsLast = i === children.length - 1;
+            stack.push([
+              children[i],
+              childIndent,
+              multipleChildren,
+              multipleChildren,
+              childIsLast,
+              childGutters,
+              false
+            ]);
+          }
+        }
+      }
+
+      // ============================================================
+      // TREE DISPLAY TEXT (pure data -> string)
+      // ============================================================
+
+      function shortenPath(p) {
+        if (typeof p !== 'string') return '';
+        if (p.startsWith('/Users/')) {
+          const parts = p.split('/');
+          if (parts.length > 2) return '~' + p.slice(('/Users/' + parts[2]).length);
+        }
+        if (p.startsWith('/home/')) {
+          const parts = p.split('/');
+          if (parts.length > 2) return '~' + p.slice(('/home/' + parts[2]).length);
+        }
+        return p;
+      }
+
+      function formatToolCall(name, args) {
+        switch (name) {
+          case 'read': {
+            const path = shortenPath(String(args.path || args.file_path || ''));
+            const offset = args.offset;
+            const limit = args.limit;
+            let display = path;
+            if (offset !== undefined || limit !== undefined) {
+              const start = offset ?? 1;
+              const end = limit !== undefined ? start + limit - 1 : '';
+              display += `:${start}${end ? `-${end}` : ''}`;
+            }
+            return `[read: ${display}]`;
+          }
+          case 'write':
+            return `[write: ${shortenPath(String(args.path || args.file_path || ''))}]`;
+          case 'edit':
+            return `[edit: ${shortenPath(String(args.path || args.file_path || ''))}]`;
+          case 'bash': {
+            const rawCmd = String(args.command || '');
+            const cmd = rawCmd.replace(/[\n\t]/g, ' ').trim().slice(0, 50);
+            return `[bash: ${cmd}${rawCmd.length > 50 ? '...' : ''}]`;
+          }
+          case 'grep':
+            return `[grep: /${args.pattern || ''}/ in ${shortenPath(String(args.path || '.'))}]`;
+          case 'find':
+            return `[find: ${args.pattern || ''} in ${shortenPath(String(args.path || '.'))}]`;
+          case 'ls':
+            return `[ls: ${shortenPath(String(args.path || '.'))}]`;
+          default: {
+            const argsStr = JSON.stringify(args).slice(0, 40);
+            return `[${name}: ${argsStr}${JSON.stringify(args).length > 40 ? '...' : ''}]`;
+          }
+        }
+      }
+
+      function escapeHtml(text) {
+        return String(text)
+          .replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&#39;');
+      }
+
+      function sanitizeMarkdownUrl(value) {
+        const href = String(value || '').trim().replace(/[\x00-\x1f\x7f]/g, '');
+        if (!href) return href;
+
+        const scheme = href.match(/^([A-Za-z][A-Za-z0-9+.-]*):/);
+        if (scheme && !/^(https?|mailto|tel|ftp)$/i.test(scheme[1])) {
+          return null;
+        }
+
+        return href;
+      }
+
+      /**
+       * Truncate string to maxLen chars, append "..." if truncated.
+       */
+      function truncate(s, maxLen = 100) {
+        if (s.length <= maxLen) return s;
+        return s.slice(0, maxLen) + '...';
+      }
+
+      /**
+       * Get display text for tree node (returns HTML string).
+       */
+      function getTreeNodeDisplayHtml(entry, label) {
+        const normalize = s => s.replace(/[\n\t]/g, ' ').trim();
+        const labelHtml = label ? `<span class="tree-label">[${escapeHtml(label)}]</span> ` : '';
+
+        switch (entry.type) {
+          case 'message': {
+            const msg = entry.message;
+            if (msg.role === 'user') {
+              const rawContent = extractContent(msg.content);
+              const skillBlock = parseSkillBlock(rawContent);
+              if (skillBlock) {
+                let treeHtml = labelHtml + `<span class="tree-role-skill">skill:</span> ${escapeHtml(skillBlock.name)}`;
+                if (skillBlock.userMessage) {
+                  treeHtml += ` · <span class="tree-role-user">user:</span> ${escapeHtml(truncate(normalize(skillBlock.userMessage)))}`;
+                }
+                return treeHtml;
+              }
+              const content = truncate(normalize(rawContent));
+              return labelHtml + `<span class="tree-role-user">user:</span> ${escapeHtml(content)}`;
+            }
+            if (msg.role === 'assistant') {
+              const textContent = truncate(normalize(extractContent(msg.content)));
+              if (textContent) {
+                return labelHtml + `<span class="tree-role-assistant">assistant:</span> ${escapeHtml(textContent)}`;
+              }
+              if (msg.stopReason === 'aborted') {
+                return labelHtml + `<span class="tree-role-assistant">assistant:</span> <span class="tree-muted">(aborted)</span>`;
+              }
+              if (msg.errorMessage) {
+                return labelHtml + `<span class="tree-role-assistant">assistant:</span> <span class="tree-error">${escapeHtml(truncate(msg.errorMessage))}</span>`;
+              }
+              return labelHtml + `<span class="tree-role-assistant">assistant:</span> <span class="tree-muted">(no text)</span>`;
+            }
+            if (msg.role === 'toolResult') {
+              const toolCall = msg.toolCallId ? toolCallMap.get(msg.toolCallId) : null;
+              if (toolCall) {
+                return labelHtml + `<span class="tree-role-tool">${escapeHtml(formatToolCall(toolCall.name, toolCall.arguments))}</span>`;
+              }
+              return labelHtml + `<span class="tree-role-tool">[${escapeHtml(msg.toolName || 'tool')}]</span>`;
+            }
+            if (msg.role === 'bashExecution') {
+              const cmd = truncate(normalize(msg.command || ''));
+              return labelHtml + `<span class="tree-role-tool">[bash]:</span> ${escapeHtml(cmd)}`;
+            }
+            return labelHtml + `<span class="tree-muted">[${escapeHtml(msg.role)}]</span>`;
+          }
+          case 'compaction':
+            return labelHtml + `<span class="tree-compaction">[compaction: ${Math.round(entry.tokensBefore/1000)}k tokens]</span>`;
+          case 'branch_summary': {
+            const summary = truncate(normalize(entry.summary || ''));
+            return labelHtml + `<span class="tree-branch-summary">[branch summary]:</span> ${escapeHtml(summary)}`;
+          }
+          case 'custom_message': {
+            const content = typeof entry.content === 'string' ? entry.content : extractContent(entry.content);
+            return labelHtml + `<span class="tree-custom">[${escapeHtml(entry.customType)}]:</span> ${escapeHtml(truncate(normalize(content)))}`;
+          }
+          case 'model_change':
+            return labelHtml + `<span class="tree-muted">[model: ${escapeHtml(entry.modelId)}]</span>`;
+          case 'thinking_level_change':
+            return labelHtml + `<span class="tree-muted">[thinking: ${escapeHtml(entry.thinkingLevel)}]</span>`;
+          default:
+            return labelHtml + `<span class="tree-muted">[${escapeHtml(entry.type)}]</span>`;
+        }
+      }
+
+      // ============================================================
+      // TREE RENDERING (DOM manipulation)
+      // ============================================================
+
+      let currentLeafId = leafId;
+      let currentTargetId = urlTargetId || leafId;
+      let treeRendered = false;
+
+      function renderTree() {
+        const tree = buildTree();
+        const activePathIds = buildActivePathIds(currentLeafId);
+        const flatNodes = flattenTree(tree, activePathIds);
+        const filtered = filterNodes(flatNodes, currentLeafId);
+        const container = document.getElementById('tree-container');
+
+        // Full render only on first call or when filter/search changes
+        if (!treeRendered) {
+          container.innerHTML = '';
+
+          for (const flatNode of filtered) {
+            const entry = flatNode.node.entry;
+            const isOnPath = activePathIds.has(entry.id);
+            const isTarget = entry.id === currentTargetId;
+
+            const div = document.createElement('div');
+            div.className = 'tree-node';
+            if (isOnPath) div.classList.add('in-path');
+            if (isTarget) div.classList.add('active');
+            div.dataset.id = entry.id;
+
+            const prefix = buildTreePrefix(flatNode);
+            const prefixSpan = document.createElement('span');
+            prefixSpan.className = 'tree-prefix';
+            prefixSpan.textContent = prefix;
+
+            const marker = document.createElement('span');
+            marker.className = 'tree-marker';
+            marker.textContent = isOnPath ? '•' : ' ';
+
+            const content = document.createElement('span');
+            content.className = 'tree-content';
+            content.innerHTML = getTreeNodeDisplayHtml(entry, flatNode.node.label);
+
+            div.appendChild(prefixSpan);
+            div.appendChild(marker);
+            div.appendChild(content);
+            // Navigate to the newest leaf through this node, but scroll to the clicked node
+            div.addEventListener('click', () => {
+              if (window.getSelection().toString()) return;
+              const leafId = findNewestLeaf(entry.id);
+              navigateTo(leafId, 'target', entry.id);
+            });
+
+            container.appendChild(div);
+          }
+
+          treeRendered = true;
+        } else {
+          // Just update markers and classes
+          const nodes = container.querySelectorAll('.tree-node');
+          for (const node of nodes) {
+            const id = node.dataset.id;
+            const isOnPath = activePathIds.has(id);
+            const isTarget = id === currentTargetId;
+
+            node.classList.toggle('in-path', isOnPath);
+            node.classList.toggle('active', isTarget);
+
+            const marker = node.querySelector('.tree-marker');
+            if (marker) {
+              marker.textContent = isOnPath ? '•' : ' ';
+            }
+          }
+        }
+
+        document.getElementById('tree-status').textContent = `${filtered.length} / ${flatNodes.length} entries`;
+
+        // Scroll active node into view after layout
+        setTimeout(() => {
+          const activeNode = container.querySelector('.tree-node.active');
+          if (activeNode) {
+            activeNode.scrollIntoView({ block: 'nearest' });
+          }
+        }, 0);
+      }
+
+      function forceTreeRerender() {
+        treeRendered = false;
+        renderTree();
+      }
+
+      // ============================================================
+      // MESSAGE RENDERING
+      // ============================================================
+
+      function formatTokens(count) {
+        if (count < 1000) return count.toString();
+        if (count < 10000) return (count / 1000).toFixed(1) + 'k';
+        if (count < 1000000) return Math.round(count / 1000) + 'k';
+        return (count / 1000000).toFixed(1) + 'M';
+      }
+
+      function formatTimestamp(ts) {
+        if (!ts) return '';
+        const date = new Date(ts);
+        return date.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+      }
+
+      function replaceTabs(text) {
+        return text.replace(/\t/g, '   ');
+      }
+
+      /** Safely coerce value to string for display. Returns null if invalid type. */
+      function str(value) {
+        if (typeof value === 'string') return value;
+        if (value == null) return '';
+        return null;
+      }
+
+      function getLanguageFromPath(filePath) {
+        const ext = filePath.split('.').pop()?.toLowerCase();
+        const extToLang = {
+          ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+          py: 'python', rb: 'ruby', rs: 'rust', go: 'go', java: 'java',
+          c: 'c', cpp: 'cpp', h: 'c', hpp: 'cpp', cs: 'csharp',
+          php: 'php', sh: 'bash', bash: 'bash', zsh: 'bash',
+          sql: 'sql', html: 'html', css: 'css', scss: 'scss',
+          json: 'json', yaml: 'yaml', yml: 'yaml', xml: 'xml',
+          md: 'markdown', dockerfile: 'dockerfile'
+        };
+        return extToLang[ext];
+      }
+
+      function findToolResult(toolCallId) {
+        for (const entry of entries) {
+          if (entry.type === 'message' && entry.message.role === 'toolResult') {
+            if (entry.message.toolCallId === toolCallId) {
+              return entry.message;
+            }
+          }
+        }
+        return null;
+      }
+
+      function formatExpandableOutput(text, maxLines, lang) {
+        text = replaceTabs(text);
+        const lines = text.split('\n');
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+
+        if (lang) {
+          let highlighted;
+          try {
+            highlighted = hljs.highlight(text, { language: lang }).value;
+          } catch {
+            highlighted = escapeHtml(text);
+          }
+
+          if (remaining > 0) {
+            const previewCode = displayLines.join('\n');
+            let previewHighlighted;
+            try {
+              previewHighlighted = hljs.highlight(previewCode, { language: lang }).value;
+            } catch {
+              previewHighlighted = escapeHtml(previewCode);
+            }
+
+            return `<div class="tool-output expandable" onclick="if(window.getSelection().toString())return;this.classList.toggle('expanded')">
+              <div class="output-preview"><pre><code class="hljs">${previewHighlighted}</code></pre>
+              <div class="expand-hint">... (${remaining} more lines)</div></div>
+              <div class="output-full"><pre><code class="hljs">${highlighted}</code></pre></div></div>`;
+          }
+
+          return `<div class="tool-output"><pre><code class="hljs">${highlighted}</code></pre></div>`;
+        }
+
+        // Plain text output
+        if (remaining > 0) {
+          let out = '<div class="tool-output expandable" onclick="if(window.getSelection().toString())return;this.classList.toggle(\'expanded\')">';
+          out += '<div class="output-preview">';
+          for (const line of displayLines) {
+            out += `<div>${escapeHtml(replaceTabs(line))}</div>`;
+          }
+          out += `<div class="expand-hint">... (${remaining} more lines)</div></div>`;
+          out += '<div class="output-full">';
+          for (const line of lines) {
+            out += `<div>${escapeHtml(replaceTabs(line))}</div>`;
+          }
+          out += '</div></div>';
+          return out;
+        }
+
+        let out = '<div class="tool-output">';
+        for (const line of displayLines) {
+          out += `<div>${escapeHtml(replaceTabs(line))}</div>`;
+        }
+        out += '</div>';
+        return out;
+      }
+
+      function renderToolCall(call) {
+        const result = findToolResult(call.id);
+        const isError = result?.isError || false;
+        const statusClass = result ? (isError ? 'error' : 'success') : 'pending';
+
+        const getResultText = () => {
+          if (!result) return '';
+          const textBlocks = result.content.filter(c => c.type === 'text');
+          return textBlocks.map(c => c.text).join('\n');
+        };
+
+        const getResultImages = () => {
+          if (!result) return [];
+          return result.content.filter(c => c.type === 'image');
+        };
+
+        const renderResultImages = () => {
+          const images = getResultImages();
+          if (images.length === 0) return '';
+          return '<div class="tool-images">' +
+            images.map(img => `<img src="data:${escapeHtml(img.mimeType || 'image/png')};base64,${escapeHtml(img.data || '')}" class="tool-image" />`).join('') +
+            '</div>';
+        };
+
+        const toolDomId = `tool-call-${escapeHtml(call.id)}`;
+        let html = `<div class="tool-execution ${statusClass}" id="${toolDomId}">`;
+        const args = call.arguments || {};
+        const name = call.name;
+
+        const invalidArg = '<span class="tool-error">[invalid arg]</span>';
+
+        switch (name) {
+          case 'bash': {
+            const command = str(args.command);
+            const cmdDisplay = command === null ? invalidArg : escapeHtml(command || '...');
+            html += `<div class="tool-command">$ ${cmdDisplay}</div>`;
+            if (result) {
+              const output = getResultText().trim();
+              if (output) html += formatExpandableOutput(output, 5);
+            }
+            break;
+          }
+          case 'read': {
+            const filePath = str(args.file_path ?? args.path);
+            const offset = args.offset;
+            const limit = args.limit;
+
+            let pathHtml = filePath === null ? invalidArg : escapeHtml(shortenPath(filePath || ''));
+            if (filePath !== null && (offset !== undefined || limit !== undefined)) {
+              const startLine = offset ?? 1;
+              const endLine = limit !== undefined ? startLine + limit - 1 : '';
+              pathHtml += `<span class="line-numbers">:${startLine}${endLine ? '-' + endLine : ''}</span>`;
+            }
+
+            html += `<div class="tool-header"><span class="tool-name">read</span> <span class="tool-path">${pathHtml}</span></div>`;
+            if (result) {
+              html += renderResultImages();
+              const output = getResultText();
+              const lang = filePath ? getLanguageFromPath(filePath) : null;
+              if (output) html += formatExpandableOutput(output, 10, lang);
+            }
+            break;
+          }
+          case 'write': {
+            const filePath = str(args.file_path ?? args.path);
+            const content = str(args.content);
+
+            html += `<div class="tool-header"><span class="tool-name">write</span> <span class="tool-path">${filePath === null ? invalidArg : escapeHtml(shortenPath(filePath || ''))}</span>`;
+            if (content !== null && content) {
+              const lines = content.split('\n');
+              if (lines.length > 10) html += ` <span class="line-count">(${lines.length} lines)</span>`;
+            }
+            html += '</div>';
+
+            if (content === null) {
+              html += `<div class="tool-error">[invalid content arg - expected string]</div>`;
+            } else if (content) {
+              const lang = filePath ? getLanguageFromPath(filePath) : null;
+              html += formatExpandableOutput(content, 10, lang);
+            }
+            if (result) {
+              const output = getResultText().trim();
+              if (output) html += `<div class="tool-output"><div>${escapeHtml(output)}</div></div>`;
+            }
+            break;
+          }
+          case 'edit': {
+            const filePath = str(args.file_path ?? args.path);
+            html += `<div class="tool-header"><span class="tool-name">edit</span> <span class="tool-path">${filePath === null ? invalidArg : escapeHtml(shortenPath(filePath || ''))}</span></div>`;
+
+            if (result?.details?.diff) {
+              const diffLines = result.details.diff.split('\n');
+              html += '<div class="tool-diff">';
+              for (const line of diffLines) {
+                const cls = line.match(/^\+/) ? 'diff-added' : line.match(/^-/) ? 'diff-removed' : 'diff-context';
+                html += `<div class="${cls}">${escapeHtml(replaceTabs(line))}</div>`;
+              }
+              html += '</div>';
+            } else if (result) {
+              const output = getResultText().trim();
+              if (output) html += `<div class="tool-output"><pre>${escapeHtml(output)}</pre></div>`;
+            }
+            break;
+          }
+          case 'ls': {
+            const dirPath = str(args.path);
+            const limit = args.limit;
+
+            let pathHtml = dirPath === null ? invalidArg : escapeHtml(shortenPath(dirPath || '.'));
+            if (limit !== undefined) {
+              pathHtml += ` <span class="line-count">(limit ${escapeHtml(String(limit))})</span>`;
+            }
+
+            html += `<div class="tool-header"><span class="tool-name">ls</span> <span class="tool-path">${pathHtml}</span></div>`;
+            if (result) {
+              const output = getResultText().trim();
+              if (output) html += formatExpandableOutput(output, 20);
+            }
+            break;
+          }
+          default: {
+            // Check for pre-rendered custom tool HTML
+            const rendered = renderedTools?.[call.id];
+            if (rendered?.callHtml || rendered?.resultHtmlCollapsed || rendered?.resultHtmlExpanded) {
+              // Custom tool with pre-rendered HTML from TUI renderer
+              if (rendered.callHtml) {
+                html += `<div class="tool-header ansi-rendered">${rendered.callHtml}</div>`;
+              } else {
+                html += `<div class="tool-header"><span class="tool-name">${escapeHtml(name)}</span></div>`;
+              }
+
+              if (rendered.resultHtmlCollapsed && rendered.resultHtmlExpanded && rendered.resultHtmlCollapsed !== rendered.resultHtmlExpanded) {
+                // Both collapsed and expanded differ - render expandable section
+                html += `<div class="tool-output expandable ansi-rendered" onclick="if(window.getSelection().toString())return;this.classList.toggle('expanded')">
+                  <div class="output-preview">${rendered.resultHtmlCollapsed}</div>
+                  <div class="output-full">${rendered.resultHtmlExpanded}</div>
+                </div>`;
+              } else if (rendered.resultHtmlExpanded) {
+                // Only expanded exists (or collapsed is identical) - show directly
+                html += `<div class="tool-output ansi-rendered">${rendered.resultHtmlExpanded}</div>`;
+              } else if (result) {
+                // No pre-rendered result HTML - fallback to JSON
+                const output = getResultText();
+                if (output) html += formatExpandableOutput(output, 10);
+              }
+            } else {
+              // Fallback to JSON display (existing behavior)
+              html += `<div class="tool-header"><span class="tool-name">${escapeHtml(name)}</span></div>`;
+              html += `<div class="tool-output"><pre>${escapeHtml(JSON.stringify(args, null, 2))}</pre></div>`;
+              if (result) {
+                const output = getResultText();
+                if (output) html += formatExpandableOutput(output, 10);
+              }
+            }
+          }
+        }
+
+        html += '</div>';
+        return html;
+      }
+
+      /**
+       * Download the session data as a JSONL file.
+       * Reconstructs the original format: header line + entry lines.
+       */
+      window.downloadSessionJson = function() {
+        // Build JSONL content: header first, then all entries
+        const lines = [];
+        if (header) {
+          lines.push(JSON.stringify({ type: 'header', ...header }));
+        }
+        for (const entry of entries) {
+          lines.push(JSON.stringify(entry));
+        }
+        const jsonlContent = lines.join('\n');
+
+        // Create download
+        const blob = new Blob([jsonlContent], { type: 'application/x-ndjson' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${header?.id || 'session'}.jsonl`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+      }
+
+      /**
+       * Build a shareable URL for a specific message.
+       * URL format: base?gistId&leafId=<leafId>&targetId=<entryId>
+       */
+      function buildShareUrl(entryId) {
+        // Check for injected base URL (used when loaded in iframe via srcdoc)
+        const baseUrlMeta = document.querySelector('meta[name="pi-share-base-url"]');
+        const baseUrl = baseUrlMeta ? baseUrlMeta.content : window.location.href.split('?')[0];
+
+        const url = new URL(window.location.href);
+        // Find the gist ID (first query param without value, e.g., ?abc123)
+        const gistId = Array.from(url.searchParams.keys()).find(k => !url.searchParams.get(k));
+
+        // Build the share URL
+        const params = new URLSearchParams();
+        params.set('leafId', currentLeafId);
+        params.set('targetId', entryId);
+
+        // If we have an injected base URL (iframe context), use it directly
+        if (baseUrlMeta) {
+          return `${baseUrl}&${params.toString()}`;
+        }
+
+        // Otherwise build from current location (direct file access)
+        url.search = gistId ? `?${gistId}&${params.toString()}` : `?${params.toString()}`;
+        return url.toString();
+      }
+
+      /**
+       * Copy text to clipboard with visual feedback.
+       * Uses navigator.clipboard with fallback to execCommand for HTTP contexts.
+       */
+      async function copyToClipboard(text, button) {
+        let success = false;
+        try {
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            await navigator.clipboard.writeText(text);
+            success = true;
+          }
+        } catch (err) {
+          // Clipboard API failed, try fallback
+        }
+
+        // Fallback for HTTP or when Clipboard API is unavailable
+        if (!success) {
+          try {
+            const textarea = document.createElement('textarea');
+            textarea.value = text;
+            textarea.style.position = 'fixed';
+            textarea.style.opacity = '0';
+            document.body.appendChild(textarea);
+            textarea.select();
+            success = document.execCommand('copy');
+            document.body.removeChild(textarea);
+          } catch (err) {
+            console.error('Failed to copy:', err);
+          }
+        }
+
+        if (success && button) {
+          const originalHtml = button.innerHTML;
+          button.innerHTML = '✓';
+          button.classList.add('copied');
+          setTimeout(() => {
+            button.innerHTML = originalHtml;
+            button.classList.remove('copied');
+          }, 1500);
+        }
+      }
+
+      /**
+       * Render the copy-link button HTML for a message.
+       */
+      function renderCopyLinkButton(entryId) {
+        return `<button class="copy-link-btn" data-entry-id="${escapeHtml(entryId)}" title="Copy link to this message">
+          <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"/>
+            <path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"/>
+          </svg>
+        </button>`;
+      }
+
+      function renderEntry(entry) {
+        const ts = formatTimestamp(entry.timestamp);
+        const tsHtml = ts ? `<div class="message-timestamp">${ts}</div>` : '';
+        const entryDomId = `entry-${escapeHtml(entry.id)}`;
+        const copyBtnHtml = renderCopyLinkButton(entry.id);
+
+        if (entry.type === 'message') {
+          const msg = entry.message;
+
+          if (msg.role === 'user') {
+            const content = msg.content;
+            const text = typeof content === 'string' ? content :
+              content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+            const skillBlock = parseSkillBlock(text);
+
+            if (skillBlock) {
+              // Collect images from content array
+              const images = Array.isArray(content) ? content.filter(c => c.type === 'image') : [];
+              const hasUserContent = skillBlock.userMessage || images.length > 0;
+              let html = `<div class="skill-user-entry" id="${entryDomId}">${copyBtnHtml}${tsHtml}`;
+
+              // Skill invocation (collapsed by default, click to expand)
+              html += `<div class="skill-invocation" onclick="if(window.getSelection().toString())return;this.classList.toggle('expanded')">
+                <div class="skill-invocation-label">[skill] ${escapeHtml(skillBlock.name)}</div>
+                <div class="skill-invocation-collapsed">${escapeHtml(skillBlock.name)} (click to expand)</div>
+                <div class="skill-invocation-content markdown-content">${safeMarkedParse(skillBlock.content)}</div>
+              </div>`;
+
+              // User message (separate block if present)
+              if (hasUserContent) {
+                html += '<div class="user-message">';
+                if (images.length > 0) {
+                  html += '<div class="message-images">';
+                  for (const img of images) {
+                    html += `<img src="data:${escapeHtml(img.mimeType || 'image/png')};base64,${escapeHtml(img.data || '')}" class="message-image" />`;
+                  }
+                  html += '</div>';
+                }
+                if (skillBlock.userMessage) {
+                  html += `<div class="markdown-content">${safeMarkedParse(skillBlock.userMessage)}</div>`;
+                }
+                html += '</div>';
+              }
+
+              html += '</div>';
+              return html;
+            }
+
+            // No skill block - normal user message
+            let html = `<div class="user-message" id="${entryDomId}">${copyBtnHtml}${tsHtml}`;
+
+            if (Array.isArray(content)) {
+              const images = content.filter(c => c.type === 'image');
+              if (images.length > 0) {
+                html += '<div class="message-images">';
+                for (const img of images) {
+                  html += `<img src="data:${escapeHtml(img.mimeType || 'image/png')};base64,${escapeHtml(img.data || '')}" class="message-image" />`;
+                }
+                html += '</div>';
+              }
+            }
+
+            if (text.trim()) {
+              html += `<div class="markdown-content">${safeMarkedParse(text)}</div>`;
+            }
+            html += '</div>';
+            return html;
+          }
+
+          if (msg.role === 'assistant') {
+            let html = `<div class="assistant-message" id="${entryDomId}">${copyBtnHtml}${tsHtml}`;
+
+            for (const block of msg.content) {
+              if (block.type === 'text' && block.text.trim()) {
+                html += `<div class="assistant-text markdown-content">${safeMarkedParse(block.text)}</div>`;
+              } else if (block.type === 'thinking' && block.thinking.trim()) {
+                html += `<div class="thinking-block">
+                  <div class="thinking-text">${escapeHtml(block.thinking)}</div>
+                  <div class="thinking-collapsed">Thinking ...</div>
+                </div>`;
+              }
+            }
+
+            for (const block of msg.content) {
+              if (block.type === 'toolCall') {
+                html += renderToolCall(block);
+              }
+            }
+
+            if (msg.stopReason === 'aborted') {
+              html += '<div class="error-text">Aborted</div>';
+            } else if (msg.stopReason === 'error') {
+              html += `<div class="error-text">Error: ${escapeHtml(msg.errorMessage || 'Unknown error')}</div>`;
+            }
+
+            html += '</div>';
+            return html;
+          }
+
+          if (msg.role === 'bashExecution') {
+            const isError = msg.cancelled || (msg.exitCode !== 0 && msg.exitCode !== null);
+            let html = `<div class="tool-execution ${isError ? 'error' : 'success'}" id="${entryDomId}">${tsHtml}`;
+            html += `<div class="tool-command">$ ${escapeHtml(msg.command)}</div>`;
+            if (msg.output) html += formatExpandableOutput(msg.output, 10);
+            if (msg.cancelled) {
+              html += '<div style="color: var(--warning)">(cancelled)</div>';
+            } else if (msg.exitCode !== 0 && msg.exitCode !== null) {
+              html += `<div style="color: var(--error)">(exit ${msg.exitCode})</div>`;
+            }
+            html += '</div>';
+            return html;
+          }
+
+          if (msg.role === 'toolResult') return '';
+        }
+
+        if (entry.type === 'model_change') {
+          return `<div class="model-change" id="${entryDomId}">${tsHtml}Switched to model: <span class="model-name">${escapeHtml(entry.provider)}/${escapeHtml(entry.modelId)}</span></div>`;
+        }
+
+        if (entry.type === 'compaction') {
+          return `<div class="compaction" id="${entryDomId}" onclick="if(window.getSelection().toString())return;this.classList.toggle('expanded')">
+            <div class="compaction-label">[compaction]</div>
+            <div class="compaction-collapsed">Compacted from ${entry.tokensBefore.toLocaleString()} tokens</div>
+            <div class="compaction-content"><strong>Compacted from ${entry.tokensBefore.toLocaleString()} tokens</strong>\n\n${escapeHtml(entry.summary)}</div>
+          </div>`;
+        }
+
+        if (entry.type === 'branch_summary') {
+          return `<div class="branch-summary" id="${entryDomId}">${tsHtml}
+            <div class="branch-summary-header">Branch Summary</div>
+            <div class="markdown-content">${safeMarkedParse(entry.summary)}</div>
+          </div>`;
+        }
+
+        if (entry.type === 'custom_message' && entry.display) {
+          return `<div class="hook-message" id="${entryDomId}">${tsHtml}
+            <div class="hook-type">[${escapeHtml(entry.customType)}]</div>
+            <div class="markdown-content">${safeMarkedParse(typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content))}</div>
+          </div>`;
+        }
+
+        return '';
+      }
+
+      // ============================================================
+      // HEADER / STATS
+      // ============================================================
+
+      function computeStats(entryList) {
+        let userMessages = 0, assistantMessages = 0, toolResults = 0;
+        let customMessages = 0, compactions = 0, branchSummaries = 0, toolCalls = 0;
+        const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        const cost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+        const models = new Set();
+
+        for (const entry of entryList) {
+          if (entry.type === 'message') {
+            const msg = entry.message;
+            if (msg.role === 'user') userMessages++;
+            if (msg.role === 'assistant') {
+              assistantMessages++;
+              if (msg.model) models.add(msg.provider ? `${msg.provider}/${msg.model}` : msg.model);
+              if (msg.usage) {
+                tokens.input += msg.usage.input || 0;
+                tokens.output += msg.usage.output || 0;
+                tokens.cacheRead += msg.usage.cacheRead || 0;
+                tokens.cacheWrite += msg.usage.cacheWrite || 0;
+                if (msg.usage.cost) {
+                  cost.input += msg.usage.cost.input || 0;
+                  cost.output += msg.usage.cost.output || 0;
+                  cost.cacheRead += msg.usage.cost.cacheRead || 0;
+                  cost.cacheWrite += msg.usage.cost.cacheWrite || 0;
+                }
+              }
+              toolCalls += msg.content.filter(c => c.type === 'toolCall').length;
+            }
+            if (msg.role === 'toolResult') toolResults++;
+          } else if (entry.type === 'compaction') {
+            compactions++;
+          } else if (entry.type === 'branch_summary') {
+            branchSummaries++;
+          } else if (entry.type === 'custom_message') {
+            customMessages++;
+          }
+        }
+
+        return { userMessages, assistantMessages, toolResults, customMessages, compactions, branchSummaries, toolCalls, tokens, cost, models: Array.from(models) };
+      }
+
+      const globalStats = computeStats(entries);
+
+      function renderHeader() {
+        const totalCost = globalStats.cost.input + globalStats.cost.output + globalStats.cost.cacheRead + globalStats.cost.cacheWrite;
+
+        const tokenParts = [];
+        if (globalStats.tokens.input) tokenParts.push(`↑${formatTokens(globalStats.tokens.input)}`);
+        if (globalStats.tokens.output) tokenParts.push(`↓${formatTokens(globalStats.tokens.output)}`);
+        if (globalStats.tokens.cacheRead) tokenParts.push(`R${formatTokens(globalStats.tokens.cacheRead)}`);
+        if (globalStats.tokens.cacheWrite) tokenParts.push(`W${formatTokens(globalStats.tokens.cacheWrite)}`);
+
+        const msgParts = [];
+        if (globalStats.userMessages) msgParts.push(`${globalStats.userMessages} user`);
+        if (globalStats.assistantMessages) msgParts.push(`${globalStats.assistantMessages} assistant`);
+        if (globalStats.toolResults) msgParts.push(`${globalStats.toolResults} tool results`);
+        if (globalStats.customMessages) msgParts.push(`${globalStats.customMessages} custom`);
+        if (globalStats.compactions) msgParts.push(`${globalStats.compactions} compactions`);
+        if (globalStats.branchSummaries) msgParts.push(`${globalStats.branchSummaries} branch summaries`);
+
+        let html = `
+          <div class="header">
+            <h1>Session: ${escapeHtml(header?.id || 'unknown')}</h1>
+            <div class="help-bar">
+              <span class="help-hint">T toggle thinking · O toggle tools</span>
+              <div class="help-actions">
+                <button type="button" class="header-toggle-btn" data-action="toggle-thinking" title="Toggle thinking (T)">Toggle thinking</button>
+                <button type="button" class="header-toggle-btn" data-action="toggle-tools" title="Toggle tools (O)">Toggle tools</button>
+                <button type="button" class="download-json-btn" onclick="downloadSessionJson()" title="Download session as JSONL">↓ JSONL</button>
+              </div>
+            </div>
+            <div class="header-info">
+              <div class="info-item"><span class="info-label">Date:</span><span class="info-value">${header?.timestamp ? new Date(header.timestamp).toLocaleString() : 'unknown'}</span></div>
+              <div class="info-item"><span class="info-label">Models:</span><span class="info-value">${escapeHtml(globalStats.models.join(', ') || 'unknown')}</span></div>
+              <div class="info-item"><span class="info-label">Messages:</span><span class="info-value">${msgParts.join(', ') || '0'}</span></div>
+              <div class="info-item"><span class="info-label">Tool Calls:</span><span class="info-value">${globalStats.toolCalls}</span></div>
+              <div class="info-item"><span class="info-label">Tokens:</span><span class="info-value">${tokenParts.join(' ') || '0'}</span></div>
+              <div class="info-item"><span class="info-label">Cost:</span><span class="info-value">${totalCost.toFixed(3)}</span></div>
+            </div>
+          </div>`;
+
+        // Render system prompt (user's base prompt, applies to all providers)
+        if (systemPrompt) {
+          const lines = systemPrompt.split('\n');
+          const previewLines = 10;
+          if (lines.length > previewLines) {
+            const preview = lines.slice(0, previewLines).join('\n');
+            const remaining = lines.length - previewLines;
+            html += `<div class="system-prompt expandable" onclick="if(window.getSelection().toString())return;this.classList.toggle('expanded')">
+              <div class="system-prompt-header">System Prompt</div>
+              <div class="system-prompt-preview">${escapeHtml(preview)}</div>
+              <div class="system-prompt-expand-hint">... (${remaining} more lines, click to expand)</div>
+              <div class="system-prompt-full">${escapeHtml(systemPrompt)}</div>
+            </div>`;
+          } else {
+            html += `<div class="system-prompt">
+              <div class="system-prompt-header">System Prompt</div>
+              <div class="system-prompt-full" style="display: block">${escapeHtml(systemPrompt)}</div>
+            </div>`;
+          }
+        }
+
+        if (tools && tools.length > 0) {
+          html += `<div class="tools-list">
+            <div class="tools-header">Available Tools</div>
+            <div class="tools-content">
+              ${tools.map(t => {
+                const hasParams = t.parameters && typeof t.parameters === 'object' && t.parameters.properties && Object.keys(t.parameters.properties).length > 0;
+                if (!hasParams) {
+                  return `<div class="tool-item"><span class="tool-item-name">${escapeHtml(t.name)}</span> - <span class="tool-item-desc">${escapeHtml(t.description)}</span></div>`;
+                }
+                const params = t.parameters;
+                const properties = params.properties;
+                const required = params.required || [];
+                let paramsHtml = '';
+                for (const [name, prop] of Object.entries(properties)) {
+                  const isRequired = required.includes(name);
+                  const typeStr = prop.type || 'any';
+                  const reqLabel = isRequired ? '<span class="tool-param-required">required</span>' : '<span class="tool-param-optional">optional</span>';
+                  paramsHtml += `<div class="tool-param"><span class="tool-param-name">${escapeHtml(name)}</span> <span class="tool-param-type">${escapeHtml(typeStr)}</span> ${reqLabel}`;
+                  if (prop.description) {
+                    paramsHtml += `<div class="tool-param-desc">${escapeHtml(prop.description)}</div>`;
+                  }
+                  paramsHtml += `</div>`;
+                }
+                return `<div class="tool-item" onclick="if(window.getSelection().toString())return;this.classList.toggle('params-expanded')"><span class="tool-item-name">${escapeHtml(t.name)}</span> - <span class="tool-item-desc">${escapeHtml(t.description)}</span> <span class="tool-params-hint"></span><div class="tool-params-content">${paramsHtml}</div></div>`;
+              }).join('')}
+            </div>
+          </div>`;
+        }
+
+        return html;
+      }
+
+      // ============================================================
+      // NAVIGATION
+      // ============================================================
+
+      // Cache for rendered entry DOM nodes
+      const entryCache = new Map();
+
+      function getScrollTargetElementId(entryId) {
+        const entry = byId.get(entryId);
+        if (entry?.type === 'message' && entry.message.role === 'toolResult' && entry.message.toolCallId) {
+          // getElementById() matches the parsed DOM id attribute, whose HTML entities
+          // were already resolved from the escaped id rendered by renderToolCall().
+          return `tool-call-${entry.message.toolCallId}`;
+        }
+        return `entry-${entryId}`;
+      }
+
+      function renderEntryToNode(entry) {
+        // Check cache first
+        if (entryCache.has(entry.id)) {
+          return entryCache.get(entry.id).cloneNode(true);
+        }
+
+        // Render to HTML string, then parse to node
+        const html = renderEntry(entry);
+        if (!html) return null;
+
+        const template = document.createElement('template');
+        template.innerHTML = html;
+        const node = template.content.firstElementChild;
+
+        // Cache the node
+        if (node) {
+          entryCache.set(entry.id, node.cloneNode(true));
+        }
+        return node;
+      }
+
+      function navigateTo(targetId, scrollMode = 'target', scrollToEntryId = null) {
+        currentLeafId = targetId;
+        currentTargetId = scrollToEntryId || targetId;
+        const path = getPath(targetId);
+
+        renderTree();
+
+        document.getElementById('header-container').innerHTML = renderHeader();
+        attachHeaderHandlers();
+
+        // Build messages using cached DOM nodes
+        const messagesEl = document.getElementById('messages');
+        const fragment = document.createDocumentFragment();
+
+        for (const entry of path) {
+          const node = renderEntryToNode(entry);
+          if (node) {
+            fragment.appendChild(node);
+          }
+        }
+
+        messagesEl.innerHTML = '';
+        messagesEl.appendChild(fragment);
+
+        // Attach click handlers for copy-link buttons
+        messagesEl.querySelectorAll('.copy-link-btn').forEach(btn => {
+          btn.addEventListener('click', (e) => {
+            e.stopPropagation();
+            const entryId = btn.dataset.entryId;
+            const shareUrl = buildShareUrl(entryId);
+            copyToClipboard(shareUrl, btn);
+          });
+        });
+
+        // Use setTimeout(0) to ensure DOM is fully laid out before scrolling
+        setTimeout(() => {
+          const content = document.getElementById('content');
+          if (scrollMode === 'bottom') {
+            content.scrollTop = content.scrollHeight;
+          } else if (scrollMode === 'target') {
+            // If scrollToEntryId is provided, scroll to that specific entry.
+            // Tool result entries are rendered inside their assistant tool-call block,
+            // so route them to the visible tool-call element instead.
+            const scrollTargetId = scrollToEntryId || targetId;
+            const targetEl = document.getElementById(getScrollTargetElementId(scrollTargetId)) ||
+              document.getElementById(`entry-${scrollTargetId}`);
+            if (targetEl) {
+              targetEl.scrollIntoView({ block: 'center' });
+              // Briefly highlight the target message
+              if (scrollToEntryId) {
+                targetEl.classList.add('highlight');
+                setTimeout(() => targetEl.classList.remove('highlight'), 2000);
+              }
+            }
+          }
+        }, 0);
+      }
+
+      // ============================================================
+      // INITIALIZATION
+      // ============================================================
+
+      // Configure marked with syntax highlighting and TUI-compatible HTML handling
+      const strictStrikethroughRegex = /^(~~)(?=[^\s~])((?:\\.|[^\\])*?(?:\\.|[^\s~\\]))\1(?=[^~]|$)/;
+
+      marked.use({
+        breaks: true,
+        gfm: true,
+        tokenizer: {
+          // Treat HTML-like input as plain text so tags are shown verbatim,
+          // matching the TUI markdown renderer.
+          html() {
+            return undefined;
+          },
+          tag() {
+            return undefined;
+          },
+          del(src) {
+            const match = strictStrikethroughRegex.exec(src);
+            if (!match) return undefined;
+            return {
+              type: 'del',
+              raw: match[0],
+              text: match[2],
+              tokens: this.lexer.inlineTokens(match[2])
+            };
+          }
+        },
+        renderer: {
+          // Sanitize link URLs with a scheme allow-list. Browsers strip C0
+          // controls from schemes, so strip them before checking and emitting.
+          link(token) {
+            const href = sanitizeMarkdownUrl(token.href);
+            if (href === null) {
+              return this.parser.parseInline(token.tokens);
+            }
+            let out = '<a href="' + escapeHtml(href) + '"';
+            if (token.title) {
+              out += ' title="' + escapeHtml(token.title) + '"';
+            }
+            out += '>' + this.parser.parseInline(token.tokens) + '</a>';
+            return out;
+          },
+          // Sanitize image src URLs with the same scheme allow-list.
+          image(token) {
+            const href = sanitizeMarkdownUrl(token.href);
+            if (href === null) {
+              return escapeHtml(token.text || '');
+            }
+            let out = '<img src="' + escapeHtml(href) + '" alt="' + escapeHtml(token.text || '') + '"';
+            if (token.title) {
+              out += ' title="' + escapeHtml(token.title) + '"';
+            }
+            out += '>';
+            return out;
+          },
+          // Code blocks: syntax highlight, no HTML escaping
+          code(token) {
+            const code = token.text;
+            const lang = token.lang;
+            let highlighted;
+            if (lang && hljs.getLanguage(lang)) {
+              try {
+                highlighted = hljs.highlight(code, { language: lang }).value;
+              } catch {
+                highlighted = escapeHtml(code);
+              }
+            } else {
+              // Auto-detect language if not specified
+              try {
+                highlighted = hljs.highlightAuto(code).value;
+              } catch {
+                highlighted = escapeHtml(code);
+              }
+            }
+            return `<pre><code class="hljs">${highlighted}</code></pre>`;
+          },
+          // Inline code: escape HTML
+          codespan(token) {
+            return `<code>${escapeHtml(token.text)}</code>`;
+          }
+        }
+      });
+
+      // Simple marked parse (escaping handled in renderers)
+      function safeMarkedParse(text) {
+        return marked.parse(text);
+      }
+
+      // Search input
+      const searchInput = document.getElementById('tree-search');
+      searchInput.addEventListener('input', (e) => {
+        searchQuery = e.target.value;
+        forceTreeRerender();
+      });
+
+      // Filter buttons
+      document.querySelectorAll('.filter-btn').forEach(btn => {
+        btn.addEventListener('click', () => {
+          document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));
+          btn.classList.add('active');
+          filterMode = btn.dataset.filter;
+          forceTreeRerender();
+        });
+      });
+
+      // Sidebar toggle
+      const sidebar = document.getElementById('sidebar');
+      const overlay = document.getElementById('sidebar-overlay');
+      const hamburger = document.getElementById('hamburger');
+      const sidebarResizer = document.getElementById('sidebar-resizer');
+      const SIDEBAR_WIDTH_STORAGE_KEY = 'pi-share:v1:sidebar-width';
+      const MIN_CONTENT_WIDTH = 320;
+
+      function isMobileLayout() {
+        return window.matchMedia('(max-width: 900px)').matches;
+      }
+
+      function getSidebarBounds() {
+        const rootStyles = getComputedStyle(document.documentElement);
+        const minWidth = parseFloat(rootStyles.getPropertyValue('--sidebar-min-width')) || 240;
+        const maxWidth = parseFloat(rootStyles.getPropertyValue('--sidebar-max-width')) || 720;
+        const viewportMaxWidth = window.innerWidth - MIN_CONTENT_WIDTH;
+        return {
+          minWidth,
+          maxWidth: Math.max(minWidth, Math.min(maxWidth, viewportMaxWidth))
+        };
+      }
+
+      function clampSidebarWidth(width) {
+        const { minWidth, maxWidth } = getSidebarBounds();
+        return Math.max(minWidth, Math.min(maxWidth, width));
+      }
+
+      function applySidebarWidth(width) {
+        document.documentElement.style.setProperty('--sidebar-width', `${Math.round(clampSidebarWidth(width))}px`);
+      }
+
+      function loadSidebarWidth() {
+        try {
+          const raw = localStorage.getItem(SIDEBAR_WIDTH_STORAGE_KEY);
+          if (raw === null) return null;
+          const width = Number(raw);
+          return Number.isFinite(width) ? width : null;
+        } catch {
+          return null;
+        }
+      }
+
+      function saveSidebarWidth(width) {
+        try {
+          localStorage.setItem(SIDEBAR_WIDTH_STORAGE_KEY, String(Math.round(clampSidebarWidth(width))));
+        } catch {
+          // Ignore storage failures (e.g. private browsing restrictions)
+        }
+      }
+
+      function setupSidebarResize() {
+        const savedWidth = loadSidebarWidth();
+        if (savedWidth !== null) {
+          applySidebarWidth(savedWidth);
+        }
+
+        if (!sidebarResizer) return;
+
+        let cleanupDrag = null;
+
+        const stopDrag = (pointerId) => {
+          if (cleanupDrag) {
+            cleanupDrag(pointerId);
+            cleanupDrag = null;
+          }
+        };
+
+        sidebarResizer.addEventListener('pointerdown', (e) => {
+          if (isMobileLayout()) return;
+
+          e.preventDefault();
+          const startX = e.clientX;
+          const startWidth = sidebar.getBoundingClientRect().width;
+          document.body.classList.add('sidebar-resizing');
+          sidebarResizer.setPointerCapture?.(e.pointerId);
+
+          const onPointerMove = (event) => {
+            applySidebarWidth(startWidth + (event.clientX - startX));
+          };
+
+          cleanupDrag = (pointerIdToRelease) => {
+            document.body.classList.remove('sidebar-resizing');
+            sidebarResizer.releasePointerCapture?.(pointerIdToRelease);
+            window.removeEventListener('pointermove', onPointerMove);
+            window.removeEventListener('pointerup', onPointerUp);
+            window.removeEventListener('pointercancel', onPointerCancel);
+            saveSidebarWidth(sidebar.getBoundingClientRect().width);
+          };
+
+          const onPointerUp = (event) => stopDrag(event.pointerId);
+          const onPointerCancel = (event) => stopDrag(event.pointerId);
+
+          window.addEventListener('pointermove', onPointerMove);
+          window.addEventListener('pointerup', onPointerUp);
+          window.addEventListener('pointercancel', onPointerCancel);
+        });
+
+        sidebarResizer.addEventListener('dblclick', () => {
+          if (isMobileLayout()) return;
+          applySidebarWidth(400);
+          saveSidebarWidth(400);
+        });
+
+        window.addEventListener('resize', () => {
+          if (isMobileLayout()) return;
+          applySidebarWidth(sidebar.getBoundingClientRect().width);
+        });
+      }
+
+      setupSidebarResize();
+
+      hamburger.addEventListener('click', () => {
+        sidebar.classList.add('open');
+        overlay.classList.add('open');
+        hamburger.style.display = 'none';
+      });
+
+      const closeSidebar = () => {
+        sidebar.classList.remove('open');
+        overlay.classList.remove('open');
+        hamburger.style.display = '';
+      };
+
+      overlay.addEventListener('click', closeSidebar);
+      document.getElementById('sidebar-close').addEventListener('click', closeSidebar);
+
+      // Toggle states
+      let thinkingExpanded = true;
+      let toolOutputsExpanded = false;
+
+      const toggleThinking = () => {
+        thinkingExpanded = !thinkingExpanded;
+        document.querySelectorAll('.thinking-text').forEach(el => {
+          el.style.display = thinkingExpanded ? '' : 'none';
+        });
+        document.querySelectorAll('.thinking-collapsed').forEach(el => {
+          el.style.display = thinkingExpanded ? 'none' : 'block';
+        });
+      };
+
+      const toggleToolOutputs = () => {
+        toolOutputsExpanded = !toolOutputsExpanded;
+        document.querySelectorAll('.tool-output.expandable').forEach(el => {
+          el.classList.toggle('expanded', toolOutputsExpanded);
+        });
+        document.querySelectorAll('.compaction').forEach(el => {
+          el.classList.toggle('expanded', toolOutputsExpanded);
+        });
+        document.querySelectorAll('.skill-invocation').forEach(el => {
+          el.classList.toggle('expanded', toolOutputsExpanded);
+        });
+      };
+
+      const attachHeaderHandlers = () => {
+        document.querySelector('[data-action="toggle-thinking"]')?.addEventListener('click', toggleThinking);
+        document.querySelector('[data-action="toggle-tools"]')?.addEventListener('click', toggleToolOutputs);
+      };
+
+      const isEditableTarget = (element) => {
+        if (!element) return false;
+        const tagName = element.tagName;
+        if (tagName === 'INPUT' || tagName === 'TEXTAREA' || tagName === 'SELECT' || tagName === 'BUTTON') {
+          return true;
+        }
+        return element.isContentEditable || Boolean(element.closest?.('[contenteditable="true"]'));
+      };
+
+      // Keyboard shortcuts
+      document.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') {
+          searchInput.value = '';
+          searchQuery = '';
+          navigateTo(leafId, 'bottom');
+        }
+
+        if (isEditableTarget(document.activeElement)) {
+          return;
+        }
+
+        const key = e.key.toLowerCase();
+        if (key === 't') {
+          e.preventDefault();
+          toggleThinking();
+        } else if (key === 'o') {
+          e.preventDefault();
+          toggleToolOutputs();
+        }
+      });
+
+      // Initial render
+      // If URL has targetId, scroll to that specific message; otherwise stay at top
+      if (leafId) {
+        if (urlTargetId && byId.has(urlTargetId)) {
+          // Deep link: navigate to leaf and scroll to target message
+          navigateTo(leafId, 'target', urlTargetId);
+        } else {
+          navigateTo(leafId, 'none');
+        }
+      } else if (entries.length > 0) {
+        // Fallback: use last entry if no leafId
+        navigateTo(entries[entries.length - 1].id, 'none');
+      }
+    })();
+
+  </script>
+</body>
+</html>
diff --git a/receiveAudioHandle.py b/receiveAudioHandle.py
index 7747b430..d819def2 100644
--- a/receiveAudioHandle.py
+++ b/receiveAudioHandle.py
@@ -3,7 +3,6 @@
 import time
 import json
 import asyncio
-from difflib import SequenceMatcher
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -76,6 +75,25 @@ def _read_smart_mode_state() -> bool:
     return False
 
 
+def _camera_access_denied() -> bool:
+    """Voice-camera access requires explicit adult policy in the shared file.
+
+    This camera-only reader intentionally fails closed on missing/invalid
+    state, even when a startup environment flag says adult mode. Re-read on
+    every access; keep in sync with dotty-behaviour/routes/voice.py.
+    """
+    try:
+        with open(_KID_MODE_STATE_FILE, "r", encoding="utf-8") as file:
+            value = file.read().strip().lower()
+    except (OSError, UnicodeError):
+        return True
+    return value not in ("false", "0", "no")
+
+
+class _VoiceCameraDenied(PermissionError):
+    """Distinct from a stale/missing image; never treat denial as a photo."""
+
+
 def _write_smart_mode_state(enabled: bool) -> None:
     try:
         os.makedirs(os.path.dirname(_SMART_MODE_STATE_FILE), exist_ok=True)
@@ -120,88 +138,67 @@ def _write_smart_mode_state(enabled: bool) -> None:
 )
 
 
-# ---------- Fuzzy phrase corrections ----------
-# Each entry: (canonical_phrase, minimum_similarity_ratio)
-# The canonical phrase is what we want. If the ASR text (or a window of it)
-# fuzzy-matches above the threshold, we substitute the canonical form.
-# Threshold 0.7 is conservative — avoids false positives on short utterances.
-_PHRASE_CORRECTIONS: list[tuple[str, float]] = [
+# ---------- Known-phrase punctuation normalization ----------
+# Never infer intent from edit-distance similarity: correct "one short joke"
+# was rewritten into "a story", causing an unintended state transition.
+_CANONICAL_PHRASES: tuple[str, ...] = (
     # Vision triggers
-    ("take a photo", 0.7),
-    ("take a picture", 0.7),
-    ("take a photo of me", 0.7),
-    ("take a picture of me", 0.7),
+    "take a photo",
+    "take a picture",
+    "take a photo of me",
+    "take a picture of me",
     # Common kid requests
-    ("tell me a story", 0.7),
-    ("sing a song", 0.7),
-    ("sing the macarena", 0.7),
-    ("dance", 0.8),
-    ("do the macarena", 0.7),
-    # Song-name fuzzy hits
-    ("play tetris", 0.7),
-    ("hall of the mountain king", 0.7),
-    ("star wars", 0.75),
-    ("pirates of the caribbean", 0.7),
-    ("super mario", 0.7),
-    ("play music", 0.75),
+    "tell me a story",
+    "sing a song",
+    "sing the macarena",
+    "dance",
+    "do the macarena",
+    # Song names
+    "play tetris",
+    "hall of the mountain king",
+    "star wars",
+    "pirates of the caribbean",
+    "super mario",
+    "play music",
     # Identity questions
-    ("what's your name", 0.7),
-    ("what is your name", 0.7),
-    ("who are you", 0.75),
+    "what's your name",
+    "what is your name",
+    "who are you",
     # Greetings
-    ("good morning", 0.7),
-    ("good night", 0.7),
-]
+    "good morning",
+    "good night",
+)
+
+# Paired quotation marks only. Apostrophes inside words (don't / Dotty's)
+# are not quote delimiters. Quoted spans remain verbatim for the LLM.
+_QUOTED_SPAN_RE = re.compile(
+    r'"[^"]*"|“[^”]*”|(?<!\w)\'[^\n]*?\'(?!\w)|‘[^\n]*?’(?!\w)'
+)
 
 
 def _apply_phrase_corrections(text: str) -> str:
-    """Fuzzy-match ASR text against known phrases and substitute if close enough.
-
-    Uses a sliding window: for each canonical phrase of N words, we check every
-    contiguous N-word window in the ASR text. If the best window exceeds the
-    similarity threshold, we replace that window with the canonical phrase.
+    """Normalize one known phrase's punctuation without changing its words.
 
-    Only the single best match (highest ratio) is applied per call to avoid
-    cascading replacements on short utterances.
+    Explicit observed name aliases remain in _apply_asr_corrections. Unknown
+    near-matches stay intact for ordinary conversation instead of manufacturing
+    camera, music, or state commands. Prefer the longest exact word sequence.
     """
-    lower = text.lower().strip()
-    words = lower.split()
-    if len(words) < 2:
-        return text  # too short to fuzzy-match phrases
-
-    best_ratio = 0.0
-    best_phrase = ""
-    best_start = 0
-    best_length = 0
-
-    for canonical, threshold in _PHRASE_CORRECTIONS:
+    # Do not erase the distinction between a command and a quoted mention.
+    if _QUOTED_SPAN_RE.search(text):
+        return text
+    original_words = text.split()
+    words = [word.lower().strip(".,!?;:\"'()[]{}‘’“”") for word in original_words]
+    for canonical in sorted(_CANONICAL_PHRASES, key=lambda p: len(p.split()), reverse=True):
         canon_words = canonical.split()
         window_size = len(canon_words)
-        if window_size > len(words):
-            continue
-
         for i in range(len(words) - window_size + 1):
-            window = " ".join(words[i : i + window_size])
-            ratio = SequenceMatcher(None, window, canonical).ratio()
-            if ratio >= threshold and ratio > best_ratio:
-                best_ratio = ratio
-                best_phrase = canonical
-                best_start = i
-                best_length = window_size
-
-    if best_ratio > 0:
-        # Rebuild using original-case words outside the match window,
-        # substituting the canonical phrase for the matched span.
-        original_words = text.split()
-        # Map word indices from lower-cased split back to original split.
-        # They should align since we only called .lower() without changing
-        # word boundaries, but guard against edge cases.
-        if len(original_words) >= best_start + best_length:
-            before = " ".join(original_words[:best_start])
-            after = " ".join(original_words[best_start + best_length :])
-            parts = [p for p in (before, best_phrase, after) if p]
-            return " ".join(parts)
-
+            # Punctuation cleanup must not concatenate separate sentences into
+            # a command, e.g. "Tell me. A story is something I dislike."
+            if any(word.rstrip("\"'‘’“”)]}").endswith((".", "!", "?"))
+                   for word in original_words[i:i + window_size - 1]):
+                continue
+            if words[i:i + window_size] == canon_words:
+                return " ".join(original_words[:i] + [canonical] + original_words[i + window_size:])
     return text
 
 
@@ -246,17 +243,35 @@ def _repl(m):
 _NON_CONVERSATIONAL_STATES = ("sleep", "security", "story_time")
 
 
+def _has_state_command(text: str, phrase: str) -> bool:
+    """Recognize a literal state phrase, excluding explicit mentions/negation.
+
+    This is deliberately not NLU: paired quotes and immediately preceding
+    do-not/don't/never (with common politeness/adverb fillers) are protected.
+    Indirect negation, hypothetical/reporting language, and unmatched quotes
+    remain outside this guard. Wake and entry shortcuts share the same rule.
+    """
+    lower = _QUOTED_SPAN_RE.sub(" [quoted] ", text.lower()).strip()
+    for match in re.finditer(r"\b" + re.escape(phrase) + r"\b", lower):
+        prefix = lower[:match.start()]
+        negated = re.search(
+            r"\b(?:do\s+not|don['’]t|never)\b"
+            r"(?:[\s,]+(?:please|ever|just|you))*[\s,]*$", prefix,
+        )
+        if not negated:
+            return True
+    return False
+
+
 def _detect_state_phrase(text: str) -> tuple[str, str] | None:
-    lower = text.lower().strip()
     for phrase, state, ack in _STATE_TRIGGER_PHRASES:
-        if phrase in lower:
+        if _has_state_command(text, phrase):
             return (state, ack)
     return None
 
 
 def _is_wake_phrase(text: str) -> bool:
-    lower = text.lower().strip()
-    return any(phrase in lower for phrase in _WAKE_PHRASES)
+    return any(_has_state_command(text, phrase) for phrase in _WAKE_PHRASES)
 
 
 _HELP_PHRASES = (
@@ -395,6 +410,8 @@ def _is_vision_request(text: str) -> bool:
 
 
 async def _handle_vision(conn: "ConnectionHandler", text: str) -> str | None:
+    if _camera_access_denied():
+        raise _VoiceCameraDenied("Camera access is disabled in Kid Mode")
     if not VISION_BRIDGE_URL:
         conn.logger.bind(tag=TAG).warning("VISION_BRIDGE_URL not set, skipping vision")
         return None
@@ -1050,11 +1067,15 @@ async def startToChat(conn: "ConnectionHandler", text):
     try:
         if text.strip().startswith("{") and text.strip().endswith("}"):
             data = json.loads(text)
-            if "speaker" in data and "content" in data:
-                speaker_name = data["speaker"]
-                _language_tag = data["language"]
-                actual_text = data["content"]
-                conn.logger.bind(tag=TAG).info(f"解析到说话人信息: {speaker_name}")
+            if isinstance(data, dict) and "content" in data:
+                # ASR may omit speaker/language metadata. Decode content before
+                # corrections, noise filtering, or intent routing; otherwise a
+                # fuzzy replacement can corrupt the JSON envelope itself.
+                actual_text = data["content"] if isinstance(data["content"], str) else ""
+                speaker_name = data.get("speaker")
+                _language_tag = data.get("language")
+                if speaker_name:
+                    conn.logger.bind(tag=TAG).info(f"解析到说话人信息: {speaker_name}")
     except (json.JSONDecodeError, KeyError):
         pass
 
@@ -1097,6 +1118,10 @@ async def startToChat(conn: "ConnectionHandler", text):
         return
 
     await send_stt_message(conn, actual_text)
+    # DOTTY-PATCH: an abort cancels the turn in flight, not the ones after it.
+    # Nothing else on the `nointent` path clears this, so a single abort frame
+    # left conn.chat() breaking out of every later reply until reconnect.
+    conn.client_abort = False
 
     thinking_frame = json.dumps({
         "type": "llm",
@@ -1162,7 +1187,15 @@ async def startToChat(conn: "ConnectionHandler", text):
 
     if _is_vision_request(user_text):
         conn.logger.bind(tag=TAG).info(f"Vision intent detected: {user_text[:60]}")
-        description = await _handle_vision(conn, user_text)
+        try:
+            description = await _handle_vision(conn, user_text)
+        except _VoiceCameraDenied:
+            conn.logger.bind(tag=TAG).info("Voice camera denied by Kid Mode policy")
+            _submit_chat(conn,
+                "[CAMERA_DISABLED] Camera access is disabled in Kid Mode. "
+                "This request did not take a photo or access a camera view. "
+                "Briefly tell the user that camera access is disabled; do not use tools.")
+            return
         if description:
             vision_prompt = (
                 f"[You just used your camera and took a photo. "
diff --git a/scripts/dotty-av-cases.json b/scripts/dotty-av-cases.json
new file mode 100644
index 00000000..3b27d966
--- /dev/null
+++ b/scripts/dotty-av-cases.json
@@ -0,0 +1,24 @@
+{
+  "ai_assistance": "OpenAI Codex (GPT-6), human-directed overnight session",
+  "cases": [
+    {"id":"V01-identity","feature":"warm conversation identity/recovery","prompt":"What is your name? Please answer in one short sentence.","asr":[["name"]],"reply":[["Dotty","Dottie","Dotti"]],"seconds":35,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":40},
+    {"id":"V02-repeat","feature":"ASR/constrained reply","prompt":"Repeat these five words: purple, robot, seven, window, Brisbane.","asr":[["purple"],["robot"],["seven","7"],["window"],["Brisbane"]],"reply":[["purple"],["robot"],["seven","7"],["window"],["Brisbane"]],"seconds":35,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":25},
+    {"id":"V03-arithmetic","feature":"comprehension/recovery","prompt":"What is twelve plus seven? Just say the answer.","asr":[["twelve","12"],["seven","7"]],"reply":[["nineteen","19"]],"seconds":35,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":10},
+    {"id":"V04-tiny-review","feature":"persona/short response","prompt":"Give yourself a very tiny performance review in two funny sentences.","asr":[["performance","review"]],"reply":[],"seconds":45,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":60},
+    {"id":"V05-toaster","feature":"creative explanation","prompt":"Explain gravity to a sleepy toaster in two short sentences.","asr":[["gravity"],["toaster"]],"reply":[["gravity","fall","pull","ground"]],"seconds":45,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":60},
+    {"id":"V06-robot-joke","feature":"expressive speech","prompt":"Tell me one short joke about being a very small robot.","asr":[["joke"],["robot"]],"reply":[],"seconds":45,"recovery_policy":"ready_for_followup","soak_safe":true,"max_response_words":60},
+    {"id":"W01-cold-wake","feature":"cold wake word","prompt":"Hi E S P. What is your name?","asr":[["name"]],"reply":[["Dotty","Dottie"]],"seconds":35,"require_wake_event":true,"recovery_policy":"ready_for_followup","required_passes":10,"enabled":false},
+    {"id":"V07-hard-thinking","feature":"think_hard","prompt":"Hi E S P. Think hard: if all wugs are blue and some blue things are round, must some wugs be round? Give one sentence.","asr":[["blue"],["round"]],"reply":[["no","not necessarily","cannot","can't"]],"seconds":110,"enabled":false},
+    {"id":"S01-sleep","feature":"sleep entry","prompt":"Hi E S P. Goodnight Dotty. Go to sleep.","asr":[["goodnight","good night","sleep"]],"reply":[],"resting_states":["sleep"],"seconds":50,"enabled":false},
+    {"id":"S02-wake","feature":"wake from sleep","prompt":"Hi E S P. Wake up. What is your name?","asr":[["wake"],["name"]],"reply":[["Dotty","Dottie"]],"seconds":65,"enabled":false}
+  ],
+  "pending_coverage": [
+    {"feature":"physical touch, face tracking/loss, spatial sound localization","status":"BLOCKED","reason":"requires physical stimuli; synthetic events only prove downstream consumers"},
+    {"feature":"screen, LEDs, movement and Shorts framing","status":"BLOCKED","reason":"preflight framing crops body and shows screen obliquely"},
+    {"feature":"memory/person tools","status":"PENDING","reason":"isolate fixture writes and preserve household records"},
+    {"feature":"think_hard and cached take_photo","status":"PENDING","reason":"need explicit tool/result assertions and deployed capability check"},
+    {"feature":"states, toggles, songs, reminders, interruption","status":"PENDING","reason":"run after acoustic baseline; per-feature cleanup required"},
+    {"feature":"dashboard, enabled ambient consumers, restart recovery","status":"PENDING","reason":"inventory live configuration and establish baseline first"},
+    {"feature":"story/security full backing and smart-model swap","status":"PENDING","reason":"reconcile code with live deployment; do not implement missing features"}
+  ]
+}
diff --git a/scripts/dotty-av-test.sh b/scripts/dotty-av-test.sh
index a6a5a386..4bffad36 100755
--- a/scripts/dotty-av-test.sh
+++ b/scripts/dotty-av-test.sh
@@ -6,12 +6,42 @@ set -euo pipefail
 
 VIDEO_DEVICE="${DOTTY_AV_VIDEO_DEVICE:-/dev/v4l/by-id/usb-046d_HD_Pro_Webcam_C920_7B90DC9F-video-index0}"
 AUDIO_DEVICE="${DOTTY_AV_AUDIO_DEVICE:-hw:C920,0}"
+AUDIO_BACKEND="${DOTTY_AV_AUDIO_BACKEND:-pulse}"
+AUDIO_SOURCE="${DOTTY_AV_AUDIO_SOURCE:-alsa_input.usb-046d_HD_Pro_Webcam_C920_7B90DC9F-02.analog-stereo}"
 SINK="${DOTTY_AV_SINK:-@DEFAULT_SINK@}"
 VIDEO_SIZE="${DOTTY_AV_VIDEO_SIZE:-1280x720}"
 VIDEO_FPS="${DOTTY_AV_VIDEO_FPS:-15}"
 VOLUME="${DOTTY_AV_VOLUME:-20}"
 RESPONSE_SECONDS="${DOTTY_AV_RESPONSE_SECONDS:-20}"
 OUT_DIR="${DOTTY_AV_OUT_DIR:-uat-sessions/$(date +%F)/av}"
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+MAX_SECONDS="${DOTTY_AV_MAX_SECONDS:-180}"
+LOSSLESS_AUDIO="${DOTTY_AV_LOSSLESS_AUDIO:-0}"
+
+cleanup() {
+    if [[ -n "${capture_pid:-}" ]]; then
+        kill -INT "$capture_pid" 2>/dev/null || true
+        wait "$capture_pid" 2>/dev/null || true
+    fi
+    [[ -z "${speech:-}" ]] || rm -f -- "$speech"
+    [[ -z "${tone:-}" ]] || rm -f -- "$tone"
+}
+trap cleanup EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+
+lock_capture() {
+    # Shared by all invocations, regardless of output directory.
+    exec 9>"${XDG_RUNTIME_DIR:-/tmp}/dotty-av-${UID}.lock"
+    flock -n 9 || { echo 'ERROR: another Dotty capture owns the camera' >&2; exit 1; }
+}
+
+bounded() {
+    [[ "$1" =~ ^[0-9]+$ && "$MAX_SECONDS" =~ ^[0-9]+$ ]] &&
+        (( $1 > 0 && $1 <= MAX_SECONDS )) || {
+        echo "ERROR: capture must be 1..${MAX_SECONDS} seconds" >&2; exit 2;
+    }
+}
 
 usage() {
     cat <<'EOF'
@@ -25,6 +55,9 @@ Usage:
 
 Environment overrides:
   DOTTY_AV_VIDEO_DEVICE, DOTTY_AV_AUDIO_DEVICE, DOTTY_AV_SINK
+  DOTTY_AV_AUDIO_BACKEND (pulse default, alsa fallback), DOTTY_AV_AUDIO_SOURCE
+  DOTTY_AV_PROMPT_WAV (optional pre-rendered local prompt)
+  DOTTY_AV_LOSSLESS_AUDIO=1 (optional same-capture float32 PCM .capture.wav)
   DOTTY_AV_VIDEO_SIZE, DOTTY_AV_VIDEO_FPS, DOTTY_AV_VOLUME
   DOTTY_AV_RESPONSE_SECONDS, DOTTY_AV_OUT_DIR
 
@@ -66,14 +99,49 @@ default_output() {
 
 capture_args() {
     printf '%s\n' \
-        -f v4l2 -input_format mjpeg -video_size "$VIDEO_SIZE" -framerate "$VIDEO_FPS" -i "$VIDEO_DEVICE" \
-        -f alsa -ac 2 -ar 32000 -i "$AUDIO_DEVICE" \
-        -c:v libx264 -preset veryfast -pix_fmt yuv420p -c:a aac -b:a 128k
+        -thread_queue_size 512 -f v4l2 -input_format mjpeg -video_size "$VIDEO_SIZE" -framerate "$VIDEO_FPS" -i "$VIDEO_DEVICE"
+    case "$AUDIO_BACKEND" in
+        alsa) printf '%s\n' -thread_queue_size 512 -f alsa -ac 2 -ar 32000 -i "$AUDIO_DEVICE" ;;
+        pulse)
+            printf '%s\n' -thread_queue_size 512 -f pulse -ac 2 -ar 32000
+            # Pulse defaults to signed 16-bit. Request float input explicitly
+            # for this experiment so >1.0 samples survive into the PCM sidecar.
+            [[ "$LOSSLESS_AUDIO" != 1 ]] || printf '%s\n' -c:a pcm_f32le
+            printf '%s\n' -i "$AUDIO_SOURCE"
+            ;;
+        *) echo "ERROR: unknown audio backend $AUDIO_BACKEND" >&2; exit 2 ;;
+    esac
+}
+
+check_capture_outputs() {
+    local output="$1" sidecar="${1%.mp4}.capture.wav"
+    [[ "$LOSSLESS_AUDIO" == 0 || "$LOSSLESS_AUDIO" == 1 ]] || {
+        echo 'ERROR: DOTTY_AV_LOSSLESS_AUDIO must be 0 or 1' >&2; exit 2;
+    }
+    [[ ! -e "$output" && ! -L "$output" ]] || {
+        echo "ERROR: output already exists: $output" >&2; exit 1;
+    }
+    if [[ "$LOSSLESS_AUDIO" == 1 && ( -e "$sidecar" || -L "$sidecar" ) ]]; then
+        echo "ERROR: output already exists: $sidecar" >&2; exit 1
+    fi
+}
+
+capture_output_args() {
+    local seconds="$1" output="$2"
+    printf '%s\n' -map 0:v:0 -map 1:a:0 \
+        -c:v libx264 -preset veryfast -pix_fmt yuv420p -c:a aac -b:a 128k -t "$seconds" "$output"
+    if [[ "$LOSSLESS_AUDIO" == 1 ]]; then
+        # One input and one process: no second microphone reader. -t is an
+        # output option and must be repeated to bound the audio-only output.
+        printf '%s\n' -map 1:a:0 -vn -c:a pcm_f32le -ar 32000 -ac 2 \
+            -t "$seconds" "${output%.mp4}.capture.wav"
+    fi
 }
 
 verify() {
     local file="$1"
     [[ -s "$file" ]] || { echo "ERROR: missing or empty recording: $file" >&2; exit 1; }
+    python "$SCRIPT_DIR/dotty_av_media.py" verify "$file"
     echo "Streams:"
     ffprobe -v error \
         -show_entries stream=codec_type,codec_name,width,height,r_frame_rate,sample_rate,channels,duration,nb_frames \
@@ -89,10 +157,16 @@ record() {
         echo "ERROR: duration must be a positive whole number" >&2
         exit 2
     }
-    [[ ! -e "$output" ]] || { echo "ERROR: output already exists: $output" >&2; exit 1; }
+    check_capture_outputs "$output"
+    bounded "$seconds"
+    lock_capture
     mkdir -p "$(dirname "$output")"
     mapfile -t args < <(capture_args)
-    ffmpeg -hide_banner -loglevel warning "${args[@]}" -t "$seconds" "$output"
+    mapfile -t outputs < <(capture_output_args "$seconds" "$output")
+    ffmpeg -nostdin -n -hide_banner -loglevel warning "${args[@]}" "${outputs[@]}" &
+    capture_pid=$!
+    wait "$capture_pid"
+    capture_pid=''
     verify "$output"
 }
 
@@ -122,10 +196,11 @@ speaker-test)
     need pactl
     set_volume "$VOLUME"
     tone="$(mktemp --suffix=.wav)"
-    trap 'rm -f "$tone"' EXIT
     ffmpeg -hide_banner -loglevel error -y -f lavfi -i 'sine=frequency=440:duration=0.5' -af 'volume=-18dB' "$tone"
     echo "Playing a quiet half-second calibration tone at ${VOLUME}%..."
-    pw-play "$tone"
+    target_sink="$SINK"
+    [[ "$target_sink" != '@DEFAULT_SINK@' ]] || target_sink="$(pactl get-default-sink)"
+    pw-play --target "$target_sink" "$tone"
     ;;
 record)
     need ffmpeg
@@ -147,23 +222,38 @@ run)
         exit 2
     }
     output="${4:-$(default_output response)}"
-    [[ ! -e "$output" ]] || { echo "ERROR: output already exists: $output" >&2; exit 1; }
+    check_capture_outputs "$output"
+    lock_capture
     mkdir -p "$(dirname "$output")"
     speech="$(mktemp --suffix=.wav)"
-    trap 'rm -f "$speech"' EXIT
-    espeak-ng -v en-au -s 145 -w "$speech" "$prompt"
+    if [[ -n "${DOTTY_AV_PROMPT_WAV:-}" ]]; then
+        [[ -s "$DOTTY_AV_PROMPT_WAV" ]] || { echo 'ERROR: missing prompt WAV' >&2; exit 2; }
+        cp -- "$DOTTY_AV_PROMPT_WAV" "$speech"
+    else
+        espeak-ng -v en-au -s 145 -w "$speech" "$prompt"
+    fi
     speech_seconds="$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$speech")"
     total_seconds="$(awk -v speech="$speech_seconds" -v response="$response_seconds" 'BEGIN { printf "%d", speech + response + 3.999 }')"
+    bounded "$total_seconds"
     set_volume "$VOLUME"
+    target_sink="$SINK"
+    [[ "$target_sink" != '@DEFAULT_SINK@' ]] || target_sink="$(pactl get-default-sink)"
+    cp -- "$speech" "${output%.mp4}.prompt.wav"
     mapfile -t args < <(capture_args)
-    ffmpeg -hide_banner -loglevel warning "${args[@]}" -t "$total_seconds" "$output" &
+    mapfile -t outputs < <(capture_output_args "$total_seconds" "$output")
+    # Launch-time anchor; first encoded sample may lag device initialization.
+    date -u +%FT%T.%NZ > "${output%.mp4}.recording-start.txt"
+    ffmpeg -nostdin -n -hide_banner -loglevel warning "${args[@]}" "${outputs[@]}" &
     capture_pid=$!
-    trap 'kill "$capture_pid" 2>/dev/null || true; rm -f "$speech"' EXIT
     echo "Recording. Prompt plays in 2 seconds; Dotty then has ${response_seconds}s to answer."
     sleep 2
-    pw-play "$speech"
+    kill -0 "$capture_pid" 2>/dev/null || { echo 'ERROR: capture failed before playback' >&2; exit 1; }
+    [[ -s "$output" ]] || { echo 'ERROR: capture produced no file before playback' >&2; exit 1; }
+    date -u +%FT%T.%NZ > "${output%.mp4}.playback-start.txt"
+    pw-play --target "$target_sink" "$speech"
+    date -u +%FT%T.%NZ > "${output%.mp4}.playback-end.txt"
     wait "$capture_pid"
-    trap 'rm -f "$speech"' EXIT
+    capture_pid=''
     verify "$output"
     echo "Saved: $output"
     ;;
diff --git a/scripts/dotty_av_clips.py b/scripts/dotty_av_clips.py
new file mode 100644
index 00000000..dcb8c2f6
--- /dev/null
+++ b/scripts/dotty_av_clips.py
@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Local review exports from Dotty case evidence. AI-assisted: OpenAI Codex (GPT-6)."""
+
+import argparse
+from datetime import datetime, timezone
+import hashlib
+import html
+import json
+import math
+import os
+from pathlib import Path
+import re
+import subprocess
+from urllib.parse import quote
+
+
+GATES = {"visual", "privacy", "captions", "music", "context"}
+
+
+def identifier(value):
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,159}", value):
+        raise ValueError("case/export name must be a simple identifier")
+    return value
+
+
+def inside(path, root):
+    path = path.resolve()
+    if not path.is_relative_to(root.resolve()):
+        raise ValueError("path escapes session directory")
+    return path
+
+
+def load(path):
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_new(path, text):
+    with path.open("x", encoding="utf-8") as output:
+        output.write(text)
+
+
+def execute(command):
+    return subprocess.run(command, check=True, capture_output=True, text=True, timeout=600)
+
+
+def media_duration(source):
+    data = json.loads(execute(["ffprobe", "-v", "error", "-show_streams", "-show_format",
+                              "-of", "json", str(source)]).stdout)
+    if not {"video", "audio"}.issubset({s["codec_type"] for s in data["streams"]}):
+        raise ValueError("source requires video and audio")
+    duration = float(data["format"]["duration"])
+    if not math.isfinite(duration) or duration <= 0:
+        raise ValueError("invalid source duration")
+    return duration
+
+
+def stamp(seconds):
+    milliseconds = round(seconds * 1000)
+    hours, rest = divmod(milliseconds, 3600000)
+    minutes, rest = divmod(rest, 60000)
+    seconds, milliseconds = divmod(rest, 1000)
+    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"
+
+
+def captions(transcript, offset, start, end):
+    """Convert response-relative segments to clip-relative SRT, retaining provenance."""
+    if not all(math.isfinite(n) for n in (offset, start, end)) or offset < 0 or start < 0 or end <= start:
+        raise ValueError("invalid caption timing")
+    cues = []
+    for segment in transcript.get("segments", []):
+        source_start = float(segment["start"]) + offset
+        source_end = float(segment["end"]) + offset
+        if not all(math.isfinite(n) for n in (source_start, source_end)) or source_end <= source_start:
+            raise ValueError("invalid transcript segment timing")
+        begin, finish = max(start, source_start), min(end, source_end)
+        text = " ".join(str(segment["text"]).split())
+        if finish > begin and text:
+            cues.append({"start": begin - start, "end": finish - start, "text": text,
+                         "source_start": source_start, "source_end": source_end})
+    srt = "\n\n".join(f"{i}\n{stamp(c['start'])} --> {stamp(c['end'])}\n{c['text']}"
+                      for i, c in enumerate(cues, 1))
+    return srt + ("\n" if srt else ""), cues
+
+
+def file_digest(path):
+    with path.open("rb") as source:
+        return hashlib.file_digest(source, "sha256").hexdigest()
+
+
+def url(path, base):
+    return quote(os.path.relpath(path, base), safe="/")
+
+
+def render_index(manifests, output):
+    rows = []
+    for path in manifests:
+        record = load(path)
+        folder = path.parent
+        evidence = record["source"]
+        root = Path(record["session"])
+        source = root / evidence["file"]
+        result = root / evidence["result_file"]
+        links = [("Video", folder / "clean.mp4"), ("Thumbnail", folder / "thumbnail.jpg"),
+                 ("Source", source), ("Case evidence", result), ("Provenance", path)]
+        if (folder / "captions.srt").exists():
+            links.append(("SRT captions", folder / "captions.srt"))
+        anchor = " · ".join(f'<a href="{url(p, output.parent)}">{label}</a>' for label, p in links)
+        rows.append("<tr>" + "".join(f"<td>{html.escape(str(value))}</td>" for value in [
+            record["title"], record["case_id"], record["verdict"], record["status"],
+            ", ".join(record["pending_reviews"]) or "all gates acknowledged",
+            f'{evidence["start_seconds"]:.3f}–{evidence["end_seconds"]:.3f}s',
+            record["commit"], record["export_state"]]) + f"<td>{anchor}</td></tr>")
+    page = ('<!doctype html><meta charset="utf-8"><title>Dotty local clip review</title>'
+            '<style>body{font:16px system-ui;margin:2em;background:#fafafa}table{border-collapse:collapse}'
+            'td,th{border:1px solid #ccc;padding:.6em;vertical-align:top}a{white-space:nowrap}</style>'
+            '<h1>Dotty local clip review</h1><p>AI-assisted exports by OpenAI Codex (GPT-6). '
+            'Human review required before posting. Test verdicts are separate from clip readiness. '
+            'Captions are provisional unless their review gate is acknowledged. Source recordings '
+            'retain the full exchange; trimming and audio normalization apply only to exports.</p>'
+            '<table><tr><th>Title suggestion</th><th>Case</th><th>Verdict</th><th>Review group</th>'
+            '<th>Pending reviews</th><th>Source interval</th><th>Commit</th><th>Export</th><th>Files</th></tr>'
+            + "".join(rows) + '</table>')
+    write_new(output, page)
+    return output
+
+
+def crop_region(value):
+    """`W:H:X:Y` in source pixels. Portrait only: the region is scaled to fill
+    1080x1920, so a landscape region would be stretched."""
+    if not re.fullmatch(r"\d+:\d+:\d+:\d+", value or ""):
+        raise ValueError("crop must be W:H:X:Y in source pixels")
+    width, height, _x, _y = (int(part) for part in value.split(":"))
+    if width < 2 or height < 2 or abs(width / height - 9 / 16) > .02:
+        raise ValueError("crop region must be 9:16 portrait")
+    return value
+
+
+def export(session, case_id, *, start=0, end=None, name=None, title=None, reviewed=(),
+           include_captions=True, crop=None):
+    session = session.resolve(strict=True)
+    case = inside(session / "cases" / identifier(case_id), session / "cases")
+    source = inside(case / "raw.mp4", session)
+    result_path = inside(case / "result.json", session)
+    result = load(result_path)
+    duration = media_duration(source)
+    end = duration if end is None else end
+    if not all(math.isfinite(n) for n in (start, end)) or not 0 <= start < end <= duration:
+        raise ValueError("clip interval must be within source duration")
+    if crop is not None:
+        crop = crop_region(crop)
+    acknowledged = set(reviewed)
+    if acknowledged - GATES:
+        raise ValueError("unknown review gate")
+    pending = sorted(GATES - acknowledged)
+    verdict = str(result.get("verdict", "INCONCLUSIVE"))
+    status = "failures" if verdict == "FAIL" else "needs-review" if pending else "ready-for-review"
+    name = identifier(name or case_id + "-" + datetime.now(timezone.utc).strftime("%H%M%S%f"))
+    destination = inside(session / "clips" / status / name, session)
+    # Exclusive directory reservation makes every export immutable, including failed attempts.
+    destination.mkdir(parents=True, exist_ok=False)
+    record = {"ai_assistance": "OpenAI Codex (GPT-6)", "session": str(session),
+              "case_id": case_id, "feature": result.get("case_id", case_id),
+              "title": title or result.get("case", {}).get("prompt", case_id),
+              "verdict": verdict, "status": status, "pending_reviews": pending,
+              "reviewed": sorted(acknowledged), "commit": result.get("commit", "unknown"),
+              "created": datetime.now(timezone.utc).isoformat(), "export_state": "incomplete",
+              "source": {"file": str(source.relative_to(session)),
+                         "result_file": str(result_path.relative_to(session)),
+                         "sha256": file_digest(source), "start_seconds": start, "end_seconds": end,
+                         "case_started": result.get("started"), "duration_seconds": duration},
+              "layout": (f"1080x1920 cropped from source region {crop}" if crop
+                         else "1080x1920 fitted; entire source frame retained"),
+              "audio": "original audio with loudness normalization; no replacement soundtrack",
+              "captions": {"state": "absent", "source": "local response.json transcription"}}
+    try:
+        execute(["ffmpeg", "-nostdin", "-n", "-v", "error", "-ss", str(start), "-i", str(source),
+                 "-t", str(end - start), "-map", "0:v:0", "-map", "0:a:0", "-vf",
+                 (f"crop={crop},scale=1080:1920:flags=lanczos,setsar=1" if crop else
+                  "scale=1080:1920:force_original_aspect_ratio=decrease:force_divisible_by=2,"
+                  "pad=1080:1920:(ow-iw)/2:(oh-ih)/2,setsar=1"),
+                 "-af", "loudnorm=I=-16:TP=-1.5:LRA=11",
+                 "-c:v", "libx264", "-preset", "fast", "-crf", "20", "-pix_fmt", "yuv420p",
+                 "-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart", str(destination / "clean.mp4")])
+        execute(["ffmpeg", "-nostdin", "-n", "-v", "error", "-ss", str(min(2, (end-start)/2)),
+                 "-i", str(destination / "clean.mp4"), "-frames:v", "1", str(destination / "thumbnail.jpg")])
+        transcript = inside(case / "response.json", session)
+        if include_captions and transcript.exists():
+            if "response_offset" not in result:
+                record["captions"]["state"] = "blocked: missing response_offset; cannot align captions"
+            else:
+                offset = float(result["response_offset"])
+                srt, cues = captions(load(transcript), offset, start, end)
+                write_new(destination / "captions.srt", srt)
+                record["captions"].update(state="reviewed" if "captions" in acknowledged else "provisional",
+                                          response_offset=offset, cues=cues)
+        record["export_state"] = "complete"
+    except Exception as exc:
+        record["error"] = str(exc)
+        raise
+    finally:
+        write_new(destination / "manifest.json", json.dumps(record, ensure_ascii=False, indent=2) + "\n")
+        render_index([destination / "manifest.json"], destination / "index.html")
+    return destination
+
+
+def index(session):
+    session = session.resolve(strict=True)
+    clips = inside(session / "clips", session)
+    clips.mkdir(exist_ok=True)
+    manifests = [p for group in ("ready-for-review", "needs-review", "failures")
+                 for p in sorted(clips.glob(f"{group}/*/manifest.json"))]
+    output = clips / ("index-" + datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%f") + ".html")
+    return render_index(manifests, output)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("export")
+    p.add_argument("session", type=Path)
+    p.add_argument("case_id")
+    p.add_argument("--start", type=float, default=0)
+    p.add_argument("--end", type=float)
+    p.add_argument("--name")
+    p.add_argument("--title")
+    p.add_argument("--reviewed", choices=sorted(GATES), action="append", default=[])
+    p.add_argument("--no-captions", action="store_true")
+    p.add_argument("--crop", help="W:H:X:Y portrait source region to fill the 9:16 frame "
+                                  "(default: fit the whole frame with padding)")
+    p = sub.add_parser("index")
+    p.add_argument("session", type=Path)
+    args = parser.parse_args()
+    if args.command == "index":
+        print(index(args.session))
+    else:
+        print(export(args.session, args.case_id, start=args.start, end=args.end, name=args.name,
+                     title=args.title, reviewed=args.reviewed, include_captions=not args.no_captions,
+                     crop=args.crop))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/dotty_av_media.py b/scripts/dotty_av_media.py
new file mode 100644
index 00000000..9c4ad661
--- /dev/null
+++ b/scripts/dotty_av_media.py
@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+"""Local A/V evidence helpers. AI-assisted: OpenAI Codex (GPT-6).
+
+Verification never infers a robot response from a nonempty audio track.
+"""
+import argparse
+from array import array
+import json
+import math
+from pathlib import Path
+import subprocess
+import sys
+
+
+def probe(path):
+    return json.loads(subprocess.check_output([
+        "ffprobe", "-v", "error", "-show_streams", "-show_format", "-of", "json", str(path)
+    ], text=True, timeout=20))
+
+
+def verify(path, expected=None):
+    data = probe(path)
+    streams = data.get("streams", [])
+    video = [s for s in streams if s.get("codec_type") == "video"]
+    audio = [s for s in streams if s.get("codec_type") == "audio"]
+    if len(video) != 1 or len(audio) != 1:
+        raise ValueError("expected exactly one video and one audio stream")
+    vd, ad = [float(s.get("duration", 0)) for s in (video[0], audio[0])]
+    if not all(math.isfinite(d) and d > 0 for d in (vd, ad)):
+        raise ValueError("empty/nonfinite stream duration")
+    if abs(vd - ad) > 1:
+        raise ValueError("audio/video duration mismatch")
+    if expected is not None and min(vd, ad) < expected - 1:
+        raise ValueError("truncated capture")
+    continuity = audio_continuity(path, int(audio[0]["sample_rate"]))
+    if continuity["decoded_seconds"] < ad - max(.25, ad * .02):
+        raise ValueError(f"audio sample loss: {continuity['decoded_seconds']:.3f}s decoded across {ad:.3f}s timeline")
+    if continuity["max_gap_seconds"] > .15:
+        raise ValueError(f"audio discontinuity: {continuity['max_gap_seconds']:.3f}s gap")
+    return {"video_seconds": vd, "audio_seconds": ad,
+            "width": video[0]["width"], "height": video[0]["height"],
+            "sample_rate": audio[0]["sample_rate"], "channels": audio[0]["channels"],
+            **continuity, "audio_quality": audio_metrics(path)}
+
+
+def pcm_metrics(pcm):
+    """Measure decoded float32 PCM without inferring speech or interaction success.
+
+    Near-full-scale samples include lossy-decoder overshoots; this is a clipping
+    warning, not proof that the microphone's analogue input clipped.
+    """
+    if len(pcm) % 4:
+        raise ValueError("incomplete float32 PCM sample")
+    samples = array("f")
+    samples.frombytes(pcm)
+    if sys.byteorder != "little":
+        samples.byteswap()
+    if not samples:
+        raise ValueError("empty decoded PCM")
+    peak = squared_sum = clipped = 0
+    for sample in samples:
+        if not math.isfinite(sample):
+            raise ValueError("nonfinite decoded PCM sample")
+        magnitude = abs(sample)
+        peak = max(peak, magnitude)
+        squared_sum += sample * sample
+        clipped += magnitude >= .999
+    rms = math.sqrt(squared_sum / len(samples))
+    ratio = clipped / len(samples)
+    silent = rms < .001 and peak < 10 ** (-45 / 20)
+    warnings = []
+    if ratio > .001:
+        warnings.append("severe_clipping: over 0.1% of decoded samples near or above full scale")
+    if silent:
+        warnings.append("near_silence: RMS below -60 dBFS and peak below -45 dBFS")
+    return {"pcm_samples": len(samples), "rms": rms, "peak": peak,
+            "rms_dbfs": 20 * math.log10(rms) if rms else None,
+            "peak_dbfs": 20 * math.log10(peak) if peak else None,
+            "clipped_samples": clipped, "clipping_ratio": ratio,
+            "clipping_threshold": .999, "near_silence": silent, "warnings": warnings,
+            "note": "Decoded PCM only; signal presence does not verify speech or a robot response. "
+                    "Lossy decoding can produce full-scale overshoots."}
+
+
+def audio_metrics(path, start=0, duration=180):
+    # Preserve native channels/rate: downmixing or resampling can mask saturation.
+    # Bound decoding to the maximum permitted case duration; never play audio.
+    if (any(isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v)
+            for v in (start, duration)) or start < 0 or duration <= 0 or start + duration > 180):
+        raise ValueError("audio metric window must lie within 0..180 seconds")
+    pcm = subprocess.check_output([
+        "ffmpeg", "-nostdin", "-v", "error", "-i", str(path), "-ss", str(start), "-t", str(duration),
+        "-map", "0:a:0", "-vn", "-sn", "-dn", "-c:a", "pcm_f32le", "-f", "f32le", "pipe:1"
+    ], timeout=45)
+    return {**pcm_metrics(pcm), "window_start_seconds": start,
+            "analysis_limit_seconds": duration, "channel_policy": "native; no downmix or resampling"}
+
+
+def audio_continuity(path, rate):
+    frames = json.loads(subprocess.check_output([
+        "ffprobe", "-v", "error", "-select_streams", "a:0", "-show_frames",
+        "-show_entries", "frame=pts_time,nb_samples", "-of", "json", str(path)
+    ], text=True, timeout=30)).get("frames", [])
+    samples, end, gap = 0, None, 0.0
+    for frame in frames:
+        count = int(frame.get("nb_samples", 0))
+        start = float(frame["pts_time"])
+        if end is not None:
+            gap = max(gap, start - end)
+        end = start + count / rate
+        samples += count
+    return {"decoded_samples": samples, "decoded_seconds": samples / rate, "max_gap_seconds": gap}
+
+
+def analysis_gain(quality):
+    """Raise quiet analysis audio towards -20 dBFS RMS, preserving 1 dB headroom."""
+    if quality["near_silence"] or not quality["rms"] or not quality["peak"]:
+        return 0.0
+    return max(0.0, min(20.0, -20.0 - quality["rms_dbfs"], -1.0 - quality["peak_dbfs"]))
+
+
+def prepare_analysis(path, output):
+    """Persist a separate normalized derivative; originals are never rewritten."""
+    derivative = Path(output).with_suffix(".analysis.wav")
+    if derivative.exists() or derivative.resolve() == Path(path).resolve():
+        raise FileExistsError("analysis derivative already exists or matches input")
+    # Measure the exact mono/16k signal supplied to Whisper before choosing gain.
+    # No normalization, VAD or transcript-derived conditioning is applied here.
+    pcm = subprocess.check_output([
+        "ffmpeg", "-nostdin", "-v", "error", "-i", str(path), "-t", "180",
+        "-map", "0:a:0", "-vn", "-ac", "1", "-ar", "16000",
+        "-c:a", "pcm_f32le", "-f", "f32le", "pipe:1"
+    ], timeout=45)
+    before = pcm_metrics(pcm)
+    gain = analysis_gain(before)
+    samples = array("f")
+    samples.frombytes(pcm)
+    if sys.byteorder != "little":
+        samples.byteswap()
+    multiplier = 10 ** (gain / 20)
+    normalized = array("f", (sample * multiplier for sample in samples))
+    if sys.byteorder != "little":
+        normalized.byteswap()
+    rendered = normalized.tobytes()
+    after = pcm_metrics(rendered)
+    subprocess.run([
+        "ffmpeg", "-nostdin", "-n", "-v", "error", "-f", "f32le", "-ar", "16000",
+        "-ac", "1", "-i", "pipe:0", "-c:a", "pcm_f32le", str(derivative)
+    ], input=rendered, check=True, capture_output=True, timeout=45)
+    return derivative, {"enabled": True, "source": str(Path(path).resolve()),
+                        "derivative": str(derivative.resolve()), "gain_db": gain,
+                        "maximum_gain_db": 20, "target_rms_dbfs": -20, "headroom_db": 1,
+                        "filter": "mono 16000 Hz float32 decode, constant amplitude gain; no limiter",
+                        "original_quality": before, "analysis_quality": after,
+                        "analysis_limit_seconds": 180}
+
+
+def validate_vad_threshold(value):
+    try:
+        threshold = float(value)
+    except (TypeError, ValueError):
+        raise ValueError("VAD threshold must be finite and between 0 and 1") from None
+    if isinstance(value, bool) or not math.isfinite(threshold) or not 0 <= threshold <= 1:
+        raise ValueError("VAD threshold must be finite and between 0 and 1")
+    return threshold
+
+
+def transcribe(path, model_path, output, normalize=False, vad_filter=True, vad_threshold=.5):
+    # Lower thresholds are explicit prospective experiments, never inferred from
+    # expected words or used to reclassify existing case evidence.
+    vad_parameters = {"threshold": validate_vad_threshold(vad_threshold)}
+    if Path(output).exists() or Path(output).resolve() == Path(path).resolve():
+        raise FileExistsError("transcription output already exists or matches input")
+    analysis_path, analysis = (path, {"enabled": False, "source": str(Path(path).resolve())})
+    if normalize:
+        analysis_path, analysis = prepare_analysis(path, output)
+    if normalize and analysis["original_quality"]["near_silence"]:
+        result = {"model": str(model_path), "language_probability": None, "segments": [],
+                  "analysis": analysis, "vad_filter": vad_filter, "vad_parameters": vad_parameters,
+                  "evidence_status": "INCONCLUSIVE", "reason": "original_audio_near_silent"}
+        with Path(output).open("x") as file:
+            json.dump(result, file, indent=2)
+            file.write("\n")
+        return result
+    # Explicit disk path + local_files_only prevent network model/media access.
+    from faster_whisper import WhisperModel
+    model = WhisperModel(str(model_path), device="cpu", compute_type="int8",
+                         cpu_threads=4, local_files_only=True)
+    segments, info = model.transcribe(str(analysis_path), language="en", beam_size=3,
+                                      vad_filter=vad_filter, vad_parameters=vad_parameters,
+                                      condition_on_previous_text=False,
+                                      word_timestamps=True)
+    result = {"model": str(model_path), "language_probability": info.language_probability,
+              "analysis": analysis, "vad_filter": vad_filter, "vad_parameters": vad_parameters,
+              "evidence_status": "UNVERIFIED_TRANSCRIPT",
+              "note": "Transcription is evidence only, including after gain. Confirm response timing, "
+                      "service TTS and content independently; noise can hallucinate words.",
+              "segments": [{"start": s.start, "end": s.end, "text": s.text,
+                            "no_speech_prob": s.no_speech_prob, "avg_logprob": s.avg_logprob,
+                            "words": [{"start": w.start, "end": w.end, "word": w.word,
+                                       "probability": w.probability} for w in (s.words or [])]}
+                           for s in segments]}
+    with Path(output).open("x") as file:
+        json.dump(result, file, indent=2)
+        file.write("\n")
+    return result
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    p = sub.add_parser("verify")
+    p.add_argument("file", type=Path)
+    p.add_argument("--expected", type=float)
+    p = sub.add_parser("transcribe")
+    p.add_argument("file", type=Path)
+    p.add_argument("--model", required=True, type=Path)
+    p.add_argument("--output", required=True, type=Path)
+    p.add_argument("--normalize", action="store_true", help="create bounded-gain analysis WAV; preserve original")
+    p.add_argument("--no-vad", action="store_true", help="diagnostic transcription only; increases hallucination risk")
+    p.add_argument("--vad-threshold", type=validate_vad_threshold, default=.5,
+                   help="explicit VAD speech threshold 0..1 (default: 0.5); recorded in provenance")
+    args = parser.parse_args()
+    if args.command == "verify":
+        print(json.dumps(verify(args.file, args.expected)))
+    else:
+        print(json.dumps(transcribe(args.file, args.model, args.output,
+                                    normalize=args.normalize, vad_filter=not args.no_vad,
+                                    vad_threshold=args.vad_threshold)))
diff --git a/scripts/dotty_overnight.py b/scripts/dotty_overnight.py
new file mode 100644
index 00000000..2370b153
--- /dev/null
+++ b/scripts/dotty_overnight.py
@@ -0,0 +1,871 @@
+#!/usr/bin/env python3
+"""Bounded overnight physical Dotty tests. AI-assisted: OpenAI Codex (GPT-6).
+
+This runner does not edit, deploy, restart or flash product code. The supervising
+agent owns controlled repair experiments. All evidence and transcription stay local.
+"""
+import argparse
+import contextlib
+from datetime import datetime, timedelta, timezone
+import fcntl
+import hashlib
+import html
+import json
+import math
+import os
+from pathlib import Path
+import random
+import re
+import shlex
+import shutil
+import signal
+import subprocess
+import time
+import uuid
+from zoneinfo import ZoneInfo
+
+from dotty_av_media import audio_metrics, verify
+
+ROOT = Path(__file__).resolve().parents[1]
+SERVICES = ("xiaozhi-esp32-server", "dotty-behaviour", "dotty-bridge", "dotty-pi")
+TZ = ZoneInfo("Australia/Brisbane")
+STOP = False
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def write_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(path.name + ".tmp")
+    with temporary.open("w") as f:
+        json.dump(data, f, indent=2, ensure_ascii=False)
+        f.write("\n")
+        f.flush()
+        os.fsync(f.fileno())
+    temporary.replace(path)
+
+
+def journal(session, event):
+    with (session / "events.jsonl").open("a") as f:
+        f.write(json.dumps({"at": now(), **event}, ensure_ascii=False) + "\n")
+        f.flush()
+        os.fsync(f.fileno())
+
+
+def load(path, default=None):
+    return json.loads(path.read_text()) if path.exists() else default
+
+
+def command(args, timeout=30, **kwargs):
+    return subprocess.run([str(a) for a in args], capture_output=True, text=True,
+                          timeout=timeout, check=True, **kwargs).stdout
+
+
+def ssh(host, argv, timeout=30, **kwargs):
+    return command(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=5", host,
+                    shlex.join([str(a) for a in argv])], timeout=timeout, **kwargs)
+
+
+def admin(host, route, body=None):
+    if route not in {"devices", "songs", "abort", "set-state", "set-toggle",
+                     "set-head-angles", "take-photo", "play-asset", "say", "inject-text"}:
+        raise ValueError("unsupported admin route")
+    # Token stays in the container: never in argv, logs, evidence or shell expansion.
+    code = '''import json,os,sys,urllib.request
+route, body = json.loads(sys.argv[1])
+headers={"Content-Type":"application/json", "X-Admin-Token":os.environ.get("DOTTY_ADMIN_TOKEN", "")}
+req=urllib.request.Request("http://127.0.0.1:8003/xiaozhi/admin/"+route,
+ data=None if body is None else json.dumps(body).encode(), headers=headers)
+with urllib.request.urlopen(req, timeout=10) as r: print(r.read().decode())
+'''
+    return json.loads(ssh(host, ["docker", "exec", "-i", "xiaozhi-esp32-server",
+                                "python", "-", json.dumps([route, body])], input=code))
+
+
+def snapshot(host):
+    result = {"at": now(), "errors": {}}
+    for name, url in {
+        "bridge": "http://localhost:8081/health",
+        "behaviour": "http://localhost:8090/health",
+        "perception": "http://localhost:8090/api/perception/state",
+    }.items():
+        try:
+            result[name] = json.loads(ssh(host, ["curl", "-fsS", "--max-time", "5", url]))
+        except Exception as exc:
+            result["errors"][name] = type(exc).__name__
+    try:
+        result["devices"] = admin(host, "devices")["devices"]
+        raw = ssh(host, ["docker", "inspect", "--format",
+                         '{{json .Name}} {{json .State.Running}} {{json .RestartCount}} {{json .Image}}',
+                         *SERVICES])
+        result["containers"] = raw.strip().splitlines()
+        result["services_running"] = len(result["containers"]) == 4 and all(
+            ' true ' in line for line in result["containers"])
+    except Exception as exc:
+        result["errors"]["containers"] = type(exc).__name__
+    return result
+
+
+def normalize(text):
+    return " ".join(re.findall(r"[a-z0-9]+", text.lower()))
+
+
+def matches(text, groups):
+    normalized = normalize(text)
+    # Token boundaries matter: "no" must not pass merely because "know" occurs.
+    return all(any(re.search(r"(?<!\w)" + re.escape(normalize(option)) + r"(?!\w)",
+                             normalized) for option in group if normalize(option))
+               for group in groups)
+
+
+class CaseBlocked(RuntimeError):
+    """An absent physical prerequisite; do not stimulate or change the robot."""
+
+
+def wake_precondition(before, device):
+    state = (before or {}).get("perception", {}).get(device, {})
+    return (bool(before) and not before.get("errors") and before.get("services_running", False)
+            and not state.get("sensor_stale", True)
+            and state.get("current_state") == "idle"
+            and state.get("listening") is False
+            # Receiver logs lack device IDs, so another connected robot would
+            # make attribution of its wake event ambiguous.
+            and (before or {}).get("devices") == [device])
+
+
+def listening_status_age(state):
+    """Use the perception server's clock; unrelated events cannot refresh chat."""
+    values = [state.get(key) for key in ("sensor_age_s", "last_event_t", "last_chat_status_t")]
+    if any(isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(v)
+           for v in values):
+        return None
+    sensor_age, event_at, chat_at = values
+    age = sensor_age + event_at - chat_at
+    return age if sensor_age >= 0 and event_at >= chat_at and age >= 0 else None
+
+
+def wake_events(log_text):
+    events = []
+    for line in log_text.splitlines():
+        # Confirmed deployed textMessageProcessor receive logger. A user saying
+        # "wake_word_detected", ASR JSON, or an admin state change cannot count.
+        match = re.search(r"\[core\.handle\.textMessageProcessor\]-INFO-收到(listen|event)消息[：:]\s*(\{.*)", line)
+        if not match:
+            continue
+        try:
+            frame, _ = json.JSONDecoder().raw_decode(match[2])
+        except (ValueError, TypeError):
+            continue
+        if frame.get("type") != match[1]:
+            continue
+        if ((frame.get("type") == "listen" and frame.get("state") == "detect")
+                or (frame.get("type") == "event" and frame.get("name") == "wake_word_detected")):
+            events.append(frame)
+    return events
+
+
+def evaluate(case, transcript, log_text, playback_end, after, device, before=None):
+    # Only response-window words count. Prompt and response transcribed separately
+    # to prevent Whisper concatenating both speakers into a single segment.
+    segments = transcript.get("segments", [])
+    response = " ".join(s["text"].strip() for s in segments
+                        if s.get("end", 0) > s.get("start", 0)
+                        and s.get("no_speech_prob", 1) < .8
+                        and s.get("avg_logprob", -10) > -1.2)
+    asr = re.findall(r"结果: (.*)", log_text)
+    # 识别文本 is logged only for recognitions handed to the chat path, so
+    # empty and ASR-REJECTed results never appear here.
+    recognised = [item.strip() for item in re.findall(r"识别文本: (.*)", log_text) if item.strip()]
+    service_tts = " ".join(text.strip() for text in re.findall(
+        r"发送音频消息: SentenceType\.(?:FIRST|MIDDLE), (.*)", log_text) if text.strip() != "None")
+    state = after.get("perception", {}).get(device, {})
+    tts = "SentenceType.FIRST" in log_text or "发送第一段语音:" in log_text
+    tts_edges = re.findall(r"SentenceType\.(FIRST|LAST)\b|(发送第一段语音:)", log_text)
+    tts_completed = bool(tts_edges) and tts_edges[-1][0] == "LAST"
+    # One recognition must contain the request; unrelated log lines cannot pool
+    # their words into evidence that Dotty understood this prompt.
+    asr_ok = any(matches(item, case.get("asr", [])) for item in asr)
+    response_ok = bool(response) and matches(response, case.get("reply", []))
+    # The reference microphone can mishear a correct reply ("Dadi" for Dotty).
+    # Service text is not acoustic proof, so agreement there cannot pass the
+    # case, but it does stop a transcription slip being scored as a robot fault.
+    service_ok = bool(service_tts) and bool(case.get("reply")) and matches(service_tts, case["reply"])
+    matched = next((item for item in recognised if matches(item, case.get("asr", []))), None)
+    # The first recognition in the capture is the prompt, whether or not it was
+    # heard correctly; a mishearing is an asr_mismatch, not someone else talking.
+    extra_speech = list(recognised)
+    if matched in extra_speech:
+        extra_speech.remove(matched)
+    elif extra_speech:
+        extra_speech.pop(0)
+    word_count = len(re.findall(r"\b\w+(?:['’]\w+)*\b", response))
+    word_limit = case.get("max_response_words")
+    if word_limit is not None and (type(word_limit) is not int or word_limit < 1):
+        raise ValueError("max_response_words must be a positive integer")
+    within_limit = word_limit is None or word_count <= word_limit
+    expected_tool = case.get("expected_tool")
+    if expected_tool is not None and (not isinstance(expected_tool, str) or not expected_tool.strip()):
+        raise ValueError("expected_tool must name one tool")
+    # This concrete PiClient marker records model tool-call construction. It
+    # cannot prove execution or a successful result, and a name mentioned in
+    # an ASR transcript or assistant answer must not satisfy it.
+    tool_calls = re.findall(r"PiClient: tool call name=([a-z_][a-z0-9_]*) id=([^\s]+)", log_text)
+    observed_tools = [name for name, ident in tool_calls if ident != "unknown"]
+    tool_observed = expected_tool in observed_tools if expected_tool else None
+    observed_wakes = wake_events(log_text)
+    requires_wake = case.get("require_wake_event", False)
+    wake_ready = wake_precondition(before, device) if requires_wake else None
+    recovered = (not after.get("errors") and after.get("services_running", False)
+                 and not state.get("sensor_stale", True)
+                 and state.get("current_state") in case.get("resting_states", ["idle"])
+                 and state.get("listening") is False)
+    if case.get("recovery_policy") == "ready_for_followup":
+        # The deployed voice path intentionally leaves automatic listening open.
+        # Count readiness only with an ended TTS turn and a fresh live state.
+        recovered = (not after.get("errors") and after.get("services_running", False)
+                     and not state.get("sensor_stale", True)
+                     and tts_completed
+                     and ((state.get("current_state") == "idle" and state.get("listening") is False)
+                          or (state.get("current_state") == "talk" and state.get("listening") is True)))
+    failure = None
+    if requires_wake and not wake_ready:
+        failure = "wake_precondition"
+    elif requires_wake and not observed_wakes:
+        failure = "no_wake_event"
+    elif not asr:
+        failure = "no_asr_or_no_wake"
+    elif not asr_ok:
+        failure = "asr_mismatch"
+    elif not tts:
+        failure = "no_tts"
+    elif not response:
+        # VAD/transcription can miss quiet physical replies despite completed
+        # TTS. Missing words alone cannot establish acoustic silence.
+        failure = "response_transcription_unavailable"
+    elif not response_ok:
+        failure = "response_transcript_disagrees_with_tts" if service_ok else "response_mismatch"
+    elif not within_limit:
+        failure = "response_too_long"
+    elif not recovered:
+        failure = "not_ready_for_followup" if case.get("recovery_policy") == "ready_for_followup" else "no_idle_recovery"
+    if extra_speech and failure not in ("wake_precondition", "no_wake_event"):
+        # Someone else spoke (or the robot answered room noise) inside the
+        # capture; neither a pass nor a failure can be attributed to the prompt.
+        failure = "extra_speech_in_capture"
+    interaction = "FAIL" if failure else "PASS"
+    verdict = "FAIL" if failure else "INCONCLUSIVE"
+    if failure == "wake_precondition":
+        interaction = verdict = "BLOCKED"
+    elif failure in ("response_transcription_unavailable", "response_transcript_disagrees_with_tts",
+                     "extra_speech_in_capture"):
+        interaction = verdict = "INCONCLUSIVE"
+    if failure is None and expected_tool and not tool_observed:
+        # Absence of a marker may mean the deployed provider lacks this logger;
+        # do not turn uncertain instrumentation into a product failure or pass.
+        interaction = "INCONCLUSIVE"
+    return {"asr": asr, "asr_match": asr_ok, "response_transcript": response,
+            "response_match": response_ok, "tts_evidence": tts, "tts_completed": tts_completed,
+            "service_tts_text": service_tts, "service_tts_match": service_ok,
+            "extra_speech": extra_speech,
+            "response_word_count": word_count, "max_response_words": word_limit,
+            "response_length": "PASS" if within_limit else "FAIL",
+            "semantic_quality": "INCONCLUSIVE",
+            "semantic_note": "Keyword/length checks do not establish creative quality or complete semantic correctness.",
+            "observed_tool_calls": observed_tools,
+            "wake_precondition": "PASS" if wake_ready else "BLOCKED" if requires_wake else "NOT_REQUIRED",
+            "observed_wake_events": observed_wakes,
+            "wake_event": "PASS" if observed_wakes else "FAIL" if requires_wake else "NOT_REQUIRED",
+            "expected_tool_call": "PASS" if tool_observed else "INCONCLUSIVE",
+            "tool_execution": "INCONCLUSIVE",
+            "tool_note": "Expected call unverified; logger availability and execution/result require review."
+                         if expected_tool and not tool_observed else "Call markers alone do not prove tool execution/result.",
+            "expression": "INCONCLUSIVE",
+            "recovery": "PASS" if recovered else "FAIL", "failure": failure,
+            "interaction": interaction,
+            "visual": "INCONCLUSIVE", "verdict": verdict,
+            "note": "Visual assertion requires frame review; automated acoustic checks are provisional."}
+
+
+def playback_verdict(heard, asr_ok, groups):
+    """The prompt was audible if the reference microphone transcript contains
+    it, or if the robot's own recogniser did. The second is the stronger
+    evidence: the reference transcript can mishear a prompt the robot got right."""
+    if heard.strip() and matches(heard, groups):
+        return "PASS", "reference_mic"
+    if asr_ok:
+        return "PASS", "robot_asr"
+    return "INCONCLUSIVE", None
+
+
+MIC_OPEN_POLLS = 90
+MIC_SETTLE_SECONDS = (4, 14)
+
+
+def warm_listening(snap, device, max_age=30, min_age=0):
+    dev = (snap or {}).get("perception", {}).get(device, {})
+    age = listening_status_age(dev)
+    fresh = (dev.get("listening") is True and not dev.get("sensor_stale", True)
+             and age is not None and min_age <= age <= max_age)
+    return fresh, age
+
+
+def open_mic(config):
+    """Opt-in (`mic_opener: admin_say`): make the robot say one word through the
+    admin route; its firmware then opens the microphone. Wait until the mic has
+    been open a few seconds so a transcript of the trailing silence cannot
+    collide with the prompt. Returns the settled snapshot, or None."""
+    admin(config["host"], "say", {"device_id": config["device"], "text": "Ready."})
+    low, high = MIC_SETTLE_SECONDS
+    for _ in range(MIC_OPEN_POLLS):
+        snap = snapshot(config["host"])
+        if warm_listening(snap, config["device"], max_age=high, min_age=low)[0]:
+            return snap
+        time.sleep(.5)
+    return None
+
+
+def space_ok(path):
+    usage = shutil.disk_usage(path)
+    return usage.free >= max(10 * 1024**3, usage.total * .1)
+
+
+def guarded_process(argv, logfile, session, timeout, env=None, deadline=None):
+    if deadline is not None and time.time() >= deadline:
+        raise TimeoutError("session deadline reached before process launch")
+    with logfile.open("w") as log:
+        p = subprocess.Popen([str(a) for a in argv], stdout=log, stderr=subprocess.STDOUT,
+                             env=env, start_new_session=True)
+        started = time.monotonic()
+        heartbeat = started
+        try:
+            while p.poll() is None:
+                if STOP or (session / "STOP").exists():
+                    raise InterruptedError("operator stopped session")
+                if time.monotonic() - started > timeout:
+                    raise TimeoutError(f"process exceeded {timeout}s")
+                if deadline is not None and time.time() >= deadline:
+                    raise TimeoutError("session deadline reached")
+                if not space_ok(session):
+                    raise RuntimeError("disk pressure")
+                if time.monotonic() - heartbeat >= 5:
+                    status = load(session / "status.json", {})
+                    write_json(session / "status.json", {**status, "heartbeat": now(),
+                               "stage": logfile.stem, "pid": os.getpid()})
+                    heartbeat = time.monotonic()
+                time.sleep(.25)
+            if p.returncode:
+                raise RuntimeError(f"process exit {p.returncode}; see {logfile.name}")
+        finally:
+            if p.poll() is None:
+                os.killpg(p.pid, signal.SIGTERM)
+                try:
+                    p.wait(timeout=8)
+                except subprocess.TimeoutExpired:
+                    os.killpg(p.pid, signal.SIGKILL)
+                    p.wait()
+
+
+def read_log_window(host, start, end, directory):
+    errors = []
+    for service in SERVICES:
+        # Bounded history. Separate stdout/stderr merged by docker logs on remote.
+        result = subprocess.run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=5", host,
+                                 shlex.join(["docker", "logs", "--timestamps", "--since", start,
+                                             "--until", end, "--tail", "3000", service])],
+                                capture_output=True, text=True, timeout=20)
+        (directory / f"{service}.log").write_text(result.stdout + result.stderr)
+        if result.returncode:
+            errors.append(service)
+    if errors:
+        raise RuntimeError("log_collection_failed:" + ",".join(errors))
+
+
+def playback_window(directory, media_seconds):
+    def stamp(name):
+        return datetime.fromisoformat((directory / name).read_text().strip().replace("Z", "+00:00"))
+    launched = stamp("raw.recording-start.txt")
+    started = stamp("raw.playback-start.txt")
+    ended = stamp("raw.playback-end.txt")
+    start = (started - launched).total_seconds()
+    end = (ended - launched).total_seconds()
+    if not 0 <= start < end < end + .4 < media_seconds:
+        raise ValueError("invalid_or_truncated_playback_window")
+    # Launch precedes the first camera sample, so this response cut is late,
+    # never early. A small tail margin excludes speaker reverberation.
+    return start, end + .4
+
+
+def capture_window_metrics(media, media_seconds, prompt_end, response_start):
+    """Keep short loud prompts visible instead of diluting them across silence.
+
+    Measure the native channel/rate signal, not the mono transcription WAV.
+    This evidence does not alter interaction verdicts or claim ADC clipping.
+    """
+    result = {"timing_note": "Approximate recording-launch-relative windows, not sample-aligned. "
+              "Prompt includes pre-roll. WAV begins at first audio sample; MP4 has its own "
+              "stream timestamps. Capture startup delay can shift either window."}
+    sources = [("container_audio", Path(media))]
+    sidecar = Path(media).with_suffix(".capture.wav")
+    if sidecar.exists():
+        sources.append(("lossless_capture", sidecar))
+    for label, source in sources:
+        result[label] = {"source": str(source),
+                         "prompt": audio_metrics(source, start=0, duration=prompt_end),
+                         "response": audio_metrics(source, start=response_start,
+                                                   duration=min(180, media_seconds) - response_start)}
+    return result
+
+
+def host_clock(host):
+    started = time.time()
+    remote = datetime.fromisoformat(ssh(host, ["date", "-u", "+%FT%T.%NZ"]).strip().replace("Z", "+00:00")).timestamp()
+    ended = time.time()
+    return {"offset_seconds": remote - (started + ended) / 2,
+            "uncertainty_seconds": (ended - started) / 2}
+
+
+def host_timestamp(local_iso, clock, margin=0):
+    stamp = datetime.fromisoformat(local_iso).timestamp() + clock["offset_seconds"] + margin
+    return datetime.fromtimestamp(stamp, timezone.utc).isoformat()
+
+
+def prepare_prompt(session, directory, config, case, env):
+    """Select local prompt evidence only; relative paths are session-relative.
+
+    Snapshot supplied waveforms per attempt so a later render cannot replace
+    the file between validation and the shell harness's playback copy.
+    """
+    env.pop("DOTTY_AV_PROMPT_WAV", None)
+    entries = config.get("prompt_wavs", {})
+    if not isinstance(entries, dict):
+        raise ValueError("prompt_wavs_invalid_mapping")
+    if case["id"] not in entries:
+        return {"source": "harness_default", "renderer": "espeak-ng", "text": case["prompt"]}
+    entry = entries[case["id"]]
+    if not isinstance(entry, dict) or any(
+            not isinstance(entry.get(key), str) or not entry[key].strip()
+            for key in ("path", "text", "sha256", "renderer")):
+        raise ValueError("prompt_wav_invalid_entry")
+    if not re.fullmatch(r"[0-9a-f]{64}", entry["sha256"]):
+        raise ValueError("prompt_wav_invalid_sha256")
+    if entry["text"] != case["prompt"]:
+        raise ValueError("prompt_wav_text_mismatch")
+    source = Path(entry["path"])
+    if not source.is_absolute():
+        source = session / source
+    source = source.resolve()
+    if not source.is_file() or source.stat().st_size == 0:
+        raise ValueError("prompt_wav_missing_or_empty")
+    selected = (directory / "selected-prompt.wav").resolve()
+    shutil.copyfile(source, selected)
+    with selected.open("rb") as audio:
+        digest = hashlib.file_digest(audio, "sha256").hexdigest()
+    if digest != entry["sha256"]:
+        raise ValueError("prompt_wav_sha256_mismatch")
+    env["DOTTY_AV_PROMPT_WAV"] = str(selected)
+    return {**entry, "source": "configured_wav", "source_path": str(source), "path": str(selected)}
+
+
+def response_vad_threshold(config):
+    value = config.get("response_vad_threshold", .5)
+    # The bounded comparison also rejects NaN and infinities. JSON booleans
+    # are not numerical settings, despite bool being an int subclass.
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not 0 <= value <= 1:
+        raise ValueError("response_vad_threshold_must_be_finite_number_between_0_and_1")
+    return float(value)
+
+
+def run_case(session, config, case):
+    ident = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S") + "-" + case["id"] + "-" + uuid.uuid4().hex[:6]
+    directory = session / "cases" / ident
+    directory.mkdir(parents=True)
+    result = {"id": ident, "case_id": case["id"], "case": case, "started": now(),
+              "commit": command(["git", "rev-parse", "HEAD"], cwd=ROOT).strip(),
+              "capture": "INCONCLUSIVE", "playback": "INCONCLUSIVE",
+              "interaction": "INCONCLUSIVE", "recovery": "INCONCLUSIVE",
+              "visual": "INCONCLUSIVE", "verdict": "INCONCLUSIVE"}
+    write_json(directory / "result.json", result)
+    write_json(session / "active.json", {"case": ident, "case_id": case["id"], "started": result["started"]})
+    journal(session, {"event": "case_started", "id": ident})
+    try:
+        result["response_vad_threshold"] = response_vad_threshold(config)
+        require_warm = case.get("require_warm_listening",
+                                case.get("recovery_policy") == "ready_for_followup"
+                                and not case.get("require_wake_event"))
+        if not isinstance(require_warm, bool):
+            raise ValueError("require_warm_listening_must_be_boolean")
+        if require_warm and case.get("require_wake_event"):
+            raise ValueError("warm_listening_and_cold_wake_preconditions_conflict")
+        result["warm_listening_precondition"] = "NOT_REQUIRED"
+        before = snapshot(config["host"])
+        write_json(directory / "before.json", before)
+        if before["errors"] or not before.get("services_running") or config["device"] not in before.get("devices", []):
+            raise RuntimeError("infrastructure_down_or_device_disconnected")
+        if case.get("require_wake_event") and not wake_precondition(before, config["device"]):
+            raise CaseBlocked("wake_precondition")
+        if require_warm:
+            fresh, age = warm_listening(before, config["device"])
+            if not fresh and config.get("mic_opener") == "admin_say":
+                # Explicit operator opt-in: the default remains "never change
+                # the robot's state to satisfy a prerequisite".
+                result["mic_opened_by"] = "admin_say"
+                opened = open_mic(config)
+                if opened:
+                    before = opened
+                    write_json(directory / "before.json", before)
+                    fresh, age = warm_listening(before, config["device"])
+            result["warm_listening_status_age_seconds"] = age
+            result["warm_listening_max_age_seconds"] = 30
+            # A prerequisite for a new trial, not a claim that an older open
+            # conversation is dead. Recovery after a long capture is separate.
+            if not fresh:
+                raise CaseBlocked("warm_listening_precondition")
+            result["warm_listening_precondition"] = "PASS"
+        sink = command(["pactl", "get-default-sink"]).strip()
+        if sink != config["sink"]:
+            raise RuntimeError("speaker_sink_changed")
+        volume = command(["pactl", "get-sink-volume", sink])
+        channels = re.findall(r"(\d+)%", volume)
+        if not channels or any(int(p) != config["volume"] for p in channels):
+            raise RuntimeError("speaker_volume_changed")
+        if command(["pactl", "get-sink-mute", sink]).strip() != "Mute: no":
+            raise RuntimeError("speaker_muted_or_unknown")
+        env = dict(os.environ, DOTTY_AV_VOLUME=str(config["volume"]),
+                   DOTTY_AV_ALLOW_HIGH_VOLUME="1", DOTTY_AV_SINK=sink,
+                   DOTTY_AV_MAX_SECONDS="180")
+        result["prompt_provenance"] = prepare_prompt(session, directory, config, case, env)
+        write_json(directory / "result.json", result)
+        media = directory / "raw.mp4"
+        result["host_clock"] = host_clock(config["host"])
+        result["capture_started"] = now()
+        guarded_process([ROOT / "scripts/dotty-av-test.sh", "run", case["prompt"],
+                         case.get("seconds", 50), media], directory / "capture.log", session, 185, env,
+                        datetime.fromisoformat(config["stop_prompts_at"]).timestamp())
+        result["capture_ended"] = now()
+        # Snapshot before transcription: evaluator runtime must not give a stuck
+        # robot extra minutes to recover unnoticed.
+        after = snapshot(config["host"])
+        write_json(directory / "after.json", after)
+        clock = result["host_clock"]
+        read_log_window(config["host"],
+                        host_timestamp(result["capture_started"], clock, -clock["uncertainty_seconds"]),
+                        host_timestamp(result["capture_ended"], clock, clock["uncertainty_seconds"]), directory)
+        result["media"] = verify(media, expected=case.get("seconds", 50))
+        result["capture"] = "PASS"
+        result["playback_process"] = "PASS"
+        # Compute actual playback offset from persisted timestamps and recording
+        # duration. Crop conservatively after playback, never use prompt audio as answer.
+        prompt_offset, offset = playback_window(directory, result["media"]["audio_seconds"])
+        result["response_offset"] = offset
+        result["timing_note"] = "Recording-launch timestamp precedes first sample; response crop is conservatively late. Early reply/latency may be lost."
+        result["native_audio_windows"] = capture_window_metrics(
+            media, result["media"]["audio_seconds"], offset - .4, offset)
+        for label, options in (("response", ["-ss", str(offset)]),
+                               ("prompt-heard", ["-ss", "0", "-t", str(offset - .4)])):
+            wav = directory / f"{label}.wav"
+            command(["ffmpeg", "-nostdin", "-n", "-v", "error", *options, "-i", media,
+                     "-vn", "-ar", "16000", "-ac", "1", wav])
+            guarded_process([config["python"], ROOT / "scripts/dotty_av_media.py", "transcribe", wav,
+                            "--model", config["model"], "--output", directory / f"{label}.json",
+                            *(["--normalize", "--vad-threshold", str(result["response_vad_threshold"])]
+                              if label == "response" else [])],
+                            directory / f"{label}-transcribe.log", session, 120,
+                            deadline=datetime.fromisoformat(config["finish_at"]).timestamp())
+            analysis = load(directory / f"{label}.json")
+            result.setdefault("transcription_analysis", {})[label] = {
+                key: analysis[key] for key in ("model", "analysis", "vad_filter", "vad_parameters")
+                if key in analysis}
+        heard = " ".join(s["text"] for s in load(directory / "prompt-heard.json")["segments"])
+        result["prompt_heard"] = heard
+        result.update(evaluate(case, load(directory / "response.json"),
+                               (directory / "xiaozhi-esp32-server.log").read_text(),
+                               offset, after, config["device"], before=before))
+        result["playback"], result["playback_evidence"] = playback_verdict(
+            heard, result["asr_match"], case.get("asr", []))
+        if result["playback"] != "PASS" and result["interaction"] == "PASS":
+            result.update(interaction="INCONCLUSIVE", failure="prompt_playback_unverified")
+        for label, seconds in (("prompt", 3), ("response", offset + 2),
+                               ("final", max(0, result["media"]["video_seconds"] - 2))):
+            command(["ffmpeg", "-nostdin", "-n", "-v", "error", "-ss", str(seconds),
+                     "-i", media, "-frames:v", "1", directory / f"frame-{label}.jpg"])
+    except CaseBlocked as exc:
+        result.update(verdict="BLOCKED", interaction="BLOCKED", failure=str(exc),
+                      exception=type(exc).__name__)
+        result[str(exc)] = "BLOCKED"
+    except Exception as exc:
+        result.update(verdict="FAIL", failure=str(exc), exception=type(exc).__name__)
+    finally:
+        result["ended"] = now()
+        write_json(directory / "result.json", result)
+        # Caller clears active only after checkpoint fsync. A crash between these
+        # writes otherwise replays a potentially side-effectful successful case.
+        journal(session, {"event": "case_finished", "id": ident, "verdict": result["verdict"],
+                          "failure": result.get("failure")})
+    return result
+
+
+def report(session):
+    results = [load(p) for p in sorted((session / "cases").glob("*/result.json"))]
+    rows = []
+    for r in results:
+        rel = "cases/" + r["id"]
+        rows.append(f'<tr><td>{html.escape(r["case_id"])}</td><td>{r["verdict"]}</td>'
+                    f'<td>{html.escape(r.get("failure") or r.get("response_transcript", ""))}</td>'
+                    f'<td><a href="{rel}/raw.mp4">Video</a> · <a href="{rel}/result.json">Evidence</a></td></tr>')
+    (session / "index.html").write_text('<!doctype html><meta charset="utf-8"><title>Dotty overnight review</title>'
+        '<style>body{font:16px system-ui;max-width:1100px;margin:2em auto}td,th{padding:.7em;border-bottom:1px solid #ccc}</style>'
+        '<h1>Dotty overnight review</h1><p>AI-assisted: OpenAI Codex (GPT-6). '
+        'Automated acoustic verdicts are provisional. Missing visual/physical coverage is not a pass.</p>'
+        '<p><a href="coverage.json">Coverage</a> · <a href="status.json">Status</a></p>'
+        '<table><tr><th>Case</th><th>Overall</th><th>Finding</th><th>Review</th></tr>' + ''.join(rows) + '</table>')
+    write_json(session / "summary.json", {"at": now(), "attempts": len(results),
+        "interaction_passes": sum(r.get("interaction") == "PASS" for r in results),
+        "failures": sum(r["verdict"] == "FAIL" for r in results),
+        "blocked": sum(r["verdict"] == "BLOCKED" for r in results),
+        "inconclusive": sum(r["verdict"] == "INCONCLUSIVE" for r in results)})
+
+
+def preflight(session, config):
+    threshold = response_vad_threshold(config)
+    data = {"at": now(), "response_vad_threshold": threshold,
+            "disk_ok": space_ok(session), "snapshot": snapshot(config["host"])}
+    for binary in ("ffmpeg", "ffprobe", "espeak-ng", "pw-play", "pactl", "flock"):
+        data[binary] = shutil.which(binary)
+    data["model_exists"] = (Path(config["model"]) / "model.bin").is_file()
+    data["camera_exists"] = Path("/dev/v4l/by-id/usb-046d_HD_Pro_Webcam_C920_7B90DC9F-video-index0").exists()
+    write_json(session / "preflight.json", data)
+    return data
+
+
+def lock(session):
+    f = (session / "runner.lock").open("w")
+    fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    return f
+
+
+@contextlib.contextmanager
+def device_lock(config):
+    # All sessions targeting this physical robot serialize, including different
+    # output directories. The shell separately locks the shared camera.
+    key = hashlib.sha256(config["device"].encode()).hexdigest()[:20]
+    path = Path("/tmp") / f"dotty-overnight-device-{key}.lock"
+    with path.open("a") as handle:
+        fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        yield
+
+
+def restore_checkpoint(session):
+    checkpoint = load(session / "checkpoint.json", {})
+    for key, value in {"completed": [], "quarantined": [], "unresolved": [], "blocked": {}, "consecutive_failures": 0,
+                       "soak": 0, "counts": {}}.items():
+        checkpoint.setdefault(key, value)
+    active = load(session / "active.json", {})
+    if active:
+        if checkpoint.get("last_attempt") == active["case"]:
+            write_json(session / "active.json", {})
+            return checkpoint
+        path = session / "cases" / active["case"] / "result.json"
+        result = load(path, {})
+        case_id = active.get("case_id") or result.get("case_id")
+        if not case_id:
+            raise RuntimeError("interrupted case identity unknown; manual evidence review required")
+        if case_id not in checkpoint["quarantined"]:
+            checkpoint["quarantined"].append(case_id)
+        if result:
+            result.update(verdict="INCONCLUSIVE", failure="interrupted_case_requires_review",
+                          ended=now())
+            write_json(path, result)
+        journal(session, {"event": "interrupted_case_requires_review", **active})
+        # Persist quarantine before clearing active: a second crash cannot lose it.
+        write_json(session / "checkpoint.json", checkpoint)
+        write_json(session / "active.json", {})
+    return checkpoint
+
+
+def record_attempt(checkpoint, case, result):
+    if result.get("id"):
+        checkpoint["last_attempt"] = result["id"]
+    counts = checkpoint["counts"].setdefault(case["id"], {"attempts": 0, "streak": 0, "failures": 0})
+    counts["attempts"] += 1
+    if result.get("verdict") == "BLOCKED":
+        checkpoint.setdefault("blocked", {})[case["id"]] = result.get("failure", "prerequisite_missing")
+        return
+    fields = [result.get(k) for k in ("capture", "playback", "interaction", "recovery")]
+    acoustic_pass = all(value == "PASS" for value in fields)
+    # An attempt that proved nothing (reference-mic slip, extra speech in the
+    # room) breaks the streak but is not evidence of a robot fault, so it must
+    # not push a healthy case toward quarantine or pause the run.
+    inconclusive = (not acoustic_pass and result.get("verdict") != "FAIL"
+                    and "FAIL" not in fields and "INCONCLUSIVE" in fields)
+    counts["streak"] = counts["streak"] + 1 if acoustic_pass else 0
+    if not acoustic_pass and not inconclusive:
+        counts["failures"] += 1
+    # A case the evidence can never settle (for example a word the reference
+    # microphone always mishears) must not hold the queue for ever.
+    counts["inconclusive"] = 0 if acoustic_pass else counts.get("inconclusive", 0) + (1 if inconclusive else 0)
+    if (counts["inconclusive"] >= case.get("max_inconclusive", 3)
+            and case["id"] not in checkpoint.setdefault("unresolved", [])):
+        checkpoint["unresolved"].append(case["id"])
+    if acoustic_pass:
+        checkpoint["consecutive_failures"] = 0
+    elif not inconclusive:
+        checkpoint["consecutive_failures"] += 1
+    # Acoustic completion remains provisional while the visual verdict is open.
+    if counts["streak"] >= case.get("required_passes", 3) and case["id"] not in checkpoint["completed"]:
+        checkpoint["completed"].append(case["id"])
+    if counts["failures"] >= case.get("max_failures", 3) and case["id"] not in checkpoint["quarantined"]:
+        checkpoint["quarantined"].append(case["id"])
+    if result.get("exception") in {"InterruptedError", "TimeoutError"} and case["id"] not in checkpoint["quarantined"]:
+        checkpoint["quarantined"].append(case["id"])
+
+
+def eligible_cases(bank, checkpoint):
+    return [c for c in bank if c["id"] not in checkpoint["quarantined"]
+            and c["id"] not in checkpoint["blocked"]
+            and c["id"] not in checkpoint.get("unresolved", [])]
+
+
+def run(session, config, catalogue, selected=None, once=False):
+    with lock(session), device_lock(config):
+        checkpoint = restore_checkpoint(session)
+        deadline = datetime.fromisoformat(config["stop_prompts_at"]).timestamp()
+        rng = random.Random(config["seed"] + checkpoint["soak"])
+        bank = [c for c in catalogue if c.get("enabled", True) and (not selected or c["id"] in selected)]
+        if not bank:
+            raise ValueError("no selected executable cases")
+        previous = time.monotonic()
+        try:
+            while not STOP and not (session / "STOP").exists() and time.time() < deadline:
+                write_json(session / "status.json", {"state": "running", "heartbeat": now(), "pid": os.getpid(),
+                    "checkpoint": checkpoint, "stop_prompts_at": config["stop_prompts_at"]})
+                if (session / "PAUSE").exists():
+                    time.sleep(1)
+                    continue
+                if checkpoint["consecutive_failures"] >= 3:
+                    write_json(session / "PAUSE", {"reason": "three consecutive failures require agent diagnosis"})
+                    write_json(session / "checkpoint.json", checkpoint)
+                    continue
+                eligible = eligible_cases(bank, checkpoint)
+                pending = [c for c in eligible if c["id"] not in checkpoint["completed"]]
+                if pending:
+                    case = pending[0]
+                else:
+                    soak_bank = [c for c in eligible if c.get("soak_safe", False)]
+                    if not soak_bank:
+                        journal(session, {"event": "no_eligible_soak_cases"})
+                        break
+                    due = previous + config.get("interval_seconds", 600)
+                    if time.monotonic() < due:
+                        time.sleep(min(1, due - time.monotonic()))
+                        continue
+                    case = soak_bank[0] if checkpoint["soak"] % 6 == 0 else rng.choice(soak_bank)
+                    checkpoint["soak"] += 1
+                # Reserve enough time for capture and both transcriptions before cutoff.
+                if deadline - time.time() < 360:
+                    break
+                if not space_ok(session):
+                    raise RuntimeError("disk pressure")
+                result = run_case(session, config, case)
+                previous = time.monotonic()
+                record_attempt(checkpoint, case, result)
+                write_json(session / "checkpoint.json", checkpoint)
+                write_json(session / "active.json", {})
+                report(session)
+                print(json.dumps({"case": case["id"], "verdict": result["verdict"], "failure": result.get("failure")}), flush=True)
+                if once:
+                    break
+                # Quiet gap between coverage cases; interruptible, no prompt overlap.
+                for _ in range(20):
+                    if STOP or (session / "STOP").exists():
+                        break
+                    time.sleep(1)
+        finally:
+            write_json(session / "status.json", {"state": "stopped", "at": now(), "checkpoint": checkpoint})
+            report(session)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("command", choices=["init", "preflight", "run", "resume", "status", "stop", "report", "admin"])
+    parser.add_argument("--session", required=True, type=Path)
+    parser.add_argument("--host", default=os.environ.get("DOTTY_TEST_HOST"),
+                        help="init only: explicit SSH user@host (or DOTTY_TEST_HOST)")
+    parser.add_argument("--device")
+    parser.add_argument("--cases", help="comma-separated case IDs")
+    parser.add_argument("--once", action="store_true")
+    parser.add_argument("--route")
+    parser.add_argument("--body", help="JSON object; tokens are resolved remotely")
+    parser.add_argument("--response-vad-threshold", type=lambda value: response_vad_threshold(
+        {"response_vad_threshold": float(value)}),
+        help="init only: response transcription VAD threshold, 0..1 (default 0.5)")
+    parser.add_argument("--mic-opener", choices=["none", "admin_say"],
+                        help="init only: 'admin_say' lets warm cases open the microphone through "
+                             "/xiaozhi/admin/say instead of blocking (default none)")
+    args = parser.parse_args()
+    if args.mic_opener is not None and args.command != "init":
+        parser.error("--mic-opener is init-only; existing sessions use config.json")
+    if args.response_vad_threshold is not None and args.command != "init":
+        parser.error("--response-vad-threshold is init-only; existing sessions use config.json")
+    if args.command == "init" and (not args.host or not args.host.strip()):
+        parser.error("init requires --host or DOTTY_TEST_HOST; no deployment host is assumed")
+    session = args.session.resolve()
+    session.mkdir(parents=True, exist_ok=True)
+    if args.command == "init":
+        if (session / "config.json").exists():
+            raise ValueError("session already initialized")
+        morning = datetime.now(TZ).replace(hour=8, minute=0, second=0, microsecond=0)
+        if morning <= datetime.now(TZ):
+            morning += timedelta(days=1)
+        devices = admin(args.host, "devices")["devices"]
+        device = args.device or (devices[0] if len(devices) == 1 else None)
+        if not device:
+            raise ValueError("select exactly one live device")
+        config = {"host": args.host, "device": device,
+            "sink": command(["pactl", "get-default-sink"]).strip(), "volume": 100,
+            "python": str(session / "evaluator-venv/bin/python"),
+            "model": str(session / "models/whisper-small.en-ct2"),
+            "response_vad_threshold": .5 if args.response_vad_threshold is None else args.response_vad_threshold,
+            "mic_opener": args.mic_opener or "none",
+            "seed": 20260912, "interval_seconds": 600,
+            "stop_prompts_at": (morning - timedelta(minutes=30)).isoformat(),
+            "finish_at": morning.isoformat(), "created": now(), "framing": "BLOCKED"}
+        write_json(session / "config.json", config)
+        for folder in ("clips/ready-for-review", "clips/needs-review", "clips/failures", "experiments", "logs"):
+            (session / folder).mkdir(parents=True, exist_ok=True)
+        write_json(session / "coverage.json", load(ROOT / "scripts/dotty-av-cases.json"))
+        print(json.dumps(config, indent=2))
+        return
+    config = load(session / "config.json")
+    if args.command == "admin":
+        print(json.dumps(admin(config["host"], args.route, json.loads(args.body) if args.body else None)))
+    elif args.command == "preflight":
+        print(json.dumps(preflight(session, config), indent=2))
+    elif args.command in {"run", "resume"}:
+        if args.command == "resume":
+            # Explicit invocation is the agent's decision to resume after review.
+            with lock(session):
+                for name in ("STOP", "PAUSE"):
+                    (session / name).unlink(missing_ok=True)
+                checkpoint = restore_checkpoint(session)
+                checkpoint["consecutive_failures"] = 0
+                write_json(session / "checkpoint.json", checkpoint)
+        run(session, config, load(ROOT / "scripts/dotty-av-cases.json")["cases"],
+            args.cases.split(",") if args.cases else None, args.once)
+    elif args.command == "stop":
+        write_json(session / "STOP", {"at": now()})
+    elif args.command == "status":
+        print(json.dumps(load(session / "status.json", {}), indent=2))
+    else:
+        report(session)
+
+
+if __name__ == "__main__":
+    def stop_signal(signum, frame):
+        global STOP
+        STOP = True
+    signal.signal(signal.SIGINT, stop_signal)
+    signal.signal(signal.SIGTERM, stop_signal)
+    main()
diff --git a/scripts/patch-tts-server-push.py b/scripts/patch-tts-server-push.py
new file mode 100644
index 00000000..73d0bf99
--- /dev/null
+++ b/scripts/patch-tts-server-push.py
@@ -0,0 +1,42 @@
+"""Patch pinned xiaozhi TTS consumers for explicit server-push arbitration."""
+
+from pathlib import Path
+import sys
+
+
+OLD = "if message.sentence_id != self.conn.sentence_id:\n"
+NEW = (
+    "if (\n"
+    "                    message.sentence_id != self.conn.sentence_id\n"
+    "                    and message.sentence_id not in getattr(\n"
+    "                        self.conn, \"_dotty_server_push_sentence_ids\", set()\n"
+    "                    )\n"
+    "                ):\n"
+)
+
+
+def patch_source(source: str) -> str:
+    if NEW in source:
+        return source
+    if OLD not in source:
+        raise ValueError("sentence-id predicate anchor not found")
+    return source.replace(OLD, NEW, 1)
+
+
+def main(root: Path) -> None:
+    patched = 0
+    for path in root.glob("*.py"):
+        source = path.read_text(encoding="utf-8")
+        if OLD not in source and NEW not in source:
+            continue
+        updated = patch_source(source)
+        if updated != source:
+            path.write_text(updated, encoding="utf-8")
+        patched += 1
+    if patched == 0:
+        raise SystemExit("no xiaozhi TTS consumers contained the expected predicate")
+    print(f"patched {patched} TTS consumer(s) for server-push arbitration")
+
+
+if __name__ == "__main__":
+    main(Path(sys.argv[1]))
diff --git a/tests/test_abort_flag_cleared_on_new_turn.py b/tests/test_abort_flag_cleared_on_new_turn.py
new file mode 100644
index 00000000..004911eb
--- /dev/null
+++ b/tests/test_abort_flag_cleared_on_new_turn.py
@@ -0,0 +1,52 @@
+"""A device/admin abort must not silence every later turn on the connection.
+
+AI-assisted (Claude). Observed on the physical robot 2026-10-05: after one
+`abort` frame, ASR and the LLM kept running but no reply was ever spoken,
+because nothing on the `nointent` chat path cleared `conn.client_abort`.
+"""
+import asyncio
+import json
+import types
+from unittest.mock import AsyncMock, MagicMock, patch
+
+from tests.test_asr_name_corrections import _module
+
+
+def _start_turn(text, **conn_overrides):
+    conn = types.SimpleNamespace(
+        logger=MagicMock(), need_bind=False, max_output_size=0,
+        client_is_speaking=False, current_state="idle", session_id="fixture",
+        websocket=types.SimpleNamespace(send=AsyncMock()),
+        executor=MagicMock(), chat=MagicMock(),
+        _dotty_toggles_synced=True, client_abort=False,
+    )
+    for key, value in conn_overrides.items():
+        setattr(conn, key, value)
+    flag_at_submit = []
+    conn.executor.submit.side_effect = lambda *a, **k: flag_at_submit.append(conn.client_abort)
+    with patch.object(_module, "handle_user_intent", new=AsyncMock(return_value=False)), \
+         patch.object(_module, "send_stt_message", new=AsyncMock()), \
+         patch.object(_module, "_mcp_call_tool", new=AsyncMock()):
+        asyncio.run(_module.startToChat(conn, json.dumps({"content": text})))
+    return conn, flag_at_submit
+
+
+def test_new_turn_after_abort_is_not_submitted_with_abort_still_set():
+    conn, flag_at_submit = _start_turn("what is your name", client_abort=True)
+    assert flag_at_submit == [False]
+    assert conn.client_abort is False
+
+
+def test_turn_handled_by_intent_does_not_touch_the_flag():
+    conn = types.SimpleNamespace(
+        logger=MagicMock(), need_bind=False, max_output_size=0,
+        client_is_speaking=False, current_state="idle", session_id="fixture",
+        websocket=types.SimpleNamespace(send=AsyncMock()),
+        executor=MagicMock(), chat=MagicMock(),
+        _dotty_toggles_synced=True, client_abort=True,
+    )
+    with patch.object(_module, "handle_user_intent", new=AsyncMock(return_value=True)), \
+         patch.object(_module, "send_stt_message", new=AsyncMock()):
+        asyncio.run(_module.startToChat(conn, json.dumps({"content": "goodbye"})))
+    assert conn.client_abort is True
+    conn.executor.submit.assert_not_called()
diff --git a/tests/test_asr_name_corrections.py b/tests/test_asr_name_corrections.py
index 2d358f9d..3934b08b 100644
--- a/tests/test_asr_name_corrections.py
+++ b/tests/test_asr_name_corrections.py
@@ -1,11 +1,14 @@
 """Regression tests for wake-name corrections on the live ASR text path."""
 
 import importlib.util
+import asyncio
+import json
 import pathlib
 import sys
 import types
 import unittest
 from contextlib import contextmanager
+from unittest.mock import AsyncMock, MagicMock, patch
 
 
 _ROOT = pathlib.Path(__file__).parent.parent
@@ -97,5 +100,67 @@ def test_alias_matching_is_word_bounded(self):
         self.assertEqual(_module._apply_asr_corrections(text), text)
 
 
+class TestAsrEnvelope(unittest.TestCase):
+    """AI-assisted GPT-6: exercise the actual post-ASR call boundary."""
+
+    def test_content_only_json_reaches_intent_as_text(self):
+        for envelope in (
+            {"content": "Purple robot seven window Brisbane."},
+            {"content": "Purple robot seven window Brisbane.", "speaker": "Fixture"},
+            {"content": "Purple robot seven window Brisbane.", "speaker": "Fixture", "language": "en"},
+        ):
+            with self.subTest(envelope=envelope):
+                conn = types.SimpleNamespace(logger=MagicMock(), need_bind=False,
+                    max_output_size=0, client_is_speaking=False)
+                intent = AsyncMock(return_value=True)
+                with patch.object(_module, "_sync_toggles_once", new=AsyncMock()), \
+                     patch.object(_module, "handle_user_intent", new=intent):
+                    asyncio.run(_module.startToChat(conn, json.dumps(envelope)))
+                intent.assert_awaited_once_with(conn, envelope["content"])
+                self.assertEqual(conn.current_speaker, envelope.get("speaker"))
+
+    def test_empty_or_nontext_content_is_not_a_spoken_request(self):
+        for content in ("", "...", None, [], {"nested": "say hello"}):
+            with self.subTest(content=content):
+                conn = types.SimpleNamespace(logger=MagicMock(), need_bind=False,
+                    max_output_size=0, client_is_speaking=False)
+                sync = AsyncMock()
+                with patch.object(_module, "_sync_toggles_once", new=sync), \
+                     patch.object(_module, "handle_user_intent", new=AsyncMock(return_value=True)):
+                    asyncio.run(_module.startToChat(conn, json.dumps({"content": content})))
+                sync.assert_not_awaited()
+
+
+class TestPhraseIntentPreservation(unittest.TestCase):
+    def test_correct_ordinary_requests_are_not_rewritten_as_commands(self):
+        for text in (
+            "Tell me one short joke about being a very small robot.",
+            "Tell me a short joke.",
+            "What is your game?",
+            "Can you sing a long note?",
+            "Please take a phota of the toy.",
+            "Tell me. A story is something I dislike.",
+        ):
+            with self.subTest(text=text):
+                self.assertEqual(_module._apply_phrase_corrections(text), text)
+
+    def test_known_phrase_punctuation_still_normalizes(self):
+        self.assertEqual(_module._apply_phrase_corrections("Good night, Dotty."),
+                         "good night Dotty.")
+        self.assertEqual(_module._apply_phrase_corrections("Please take a photo, now."),
+                         "Please take a photo now.")
+
+    def test_actual_json_joke_turn_reaches_routing_unchanged(self):
+        text = "Tell me one short joke about being a very small robot."
+        conn = types.SimpleNamespace(logger=MagicMock(), need_bind=False,
+            max_output_size=0, client_is_speaking=False)
+        intent = AsyncMock(return_value=True)
+        with patch.object(_module, "_sync_toggles_once", new=AsyncMock()), \
+             patch.object(_module, "handle_user_intent", new=intent):
+            asyncio.run(_module.startToChat(conn, json.dumps({"content": text})))
+        intent.assert_awaited_once_with(conn, text)
+        self.assertIsNone(_module._detect_state_phrase(intent.await_args.args[1]))
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_bridge_routes.py b/tests/test_bridge_routes.py
index 75f45276..94d80477 100644
--- a/tests/test_bridge_routes.py
+++ b/tests/test_bridge_routes.py
@@ -321,92 +321,5 @@ def test_scene_synthesis_cache_getter_degrades_on_timeout(self):
         self.assertEqual(result, {})
 
 
-# ---------------------------------------------------------------------------
-# Sound-balance series getter — rewired in #115 Tile 5
-# ---------------------------------------------------------------------------
-
-
-class SoundBalanceGetterTests(unittest.TestCase):
-    """Smoke tests for the dotty-behaviour-backed sound-balance series
-    getter. Resolves the device id from the perception state getter
-    (single-robot heuristic) and pulls the sparkline series."""
-
-    def setUp(self) -> None:
-        bridge_app._dotty_behaviour_cache.clear()
-
-    def _patch_get(self, by_path):
-        """Monkeypatch requests.get to dispatch on URL path. ``by_path``
-        is a dict mapping path-substring → response (or Exception)."""
-        original = bridge_app.requests.get
-
-        def fake_get(url, *args, **kwargs):
-            for needle, response in by_path.items():
-                if needle in url:
-                    if isinstance(response, Exception):
-                        raise response
-                    return response
-            raise AssertionError(f"unexpected URL fetched: {url}")
-
-        bridge_app.requests.get = fake_get
-        self.addCleanup(lambda: setattr(bridge_app.requests, "get", original))
-
-    def test_sound_balance_series_returns_fetched_list(self):
-        class StateResp:
-            def raise_for_status(self):
-                return None
-
-            def json(self):
-                return {"dev-1": {"face_present": True}}
-
-        class BalanceResp:
-            def raise_for_status(self):
-                return None
-
-            def json(self):
-                return [0.1, 0.5, 0.9]
-
-        self._patch_get(
-            {
-                "/api/perception/state": StateResp(),
-                "/api/perception/sound-balance/": BalanceResp(),
-            }
-        )
-        result = bridge_app._dashboard_sound_balance_series()
-        self.assertEqual(result, [0.1, 0.5, 0.9])
-
-    def test_sound_balance_series_no_device_returns_empty(self):
-        class EmptyStateResp:
-            def raise_for_status(self):
-                return None
-
-            def json(self):
-                return {}
-
-        self._patch_get({"/api/perception/state": EmptyStateResp()})
-        result = bridge_app._dashboard_sound_balance_series()
-        self.assertEqual(result, [])
-
-    def test_sound_balance_series_degrades_on_connection_error(self):
-        import requests as _requests
-
-        class StateResp:
-            def raise_for_status(self):
-                return None
-
-            def json(self):
-                return {"dev-1": {"face_present": True}}
-
-        self._patch_get(
-            {
-                "/api/perception/state": StateResp(),
-                "/api/perception/sound-balance/": _requests.exceptions.ConnectionError(
-                    "simulated"
-                ),
-            }
-        )
-        result = bridge_app._dashboard_sound_balance_series()
-        self.assertEqual(result, [])
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_dashboard_feed_and_actions.py b/tests/test_dashboard_feed_and_actions.py
new file mode 100644
index 00000000..ac1806ce
--- /dev/null
+++ b/tests/test_dashboard_feed_and_actions.py
@@ -0,0 +1,242 @@
+"""Tests for the perception-feed relay, the no-wait inject helper, the
+last-seen fallback, the voice-tool inventory, and the voice-turn ingest.
+
+The dashboard's live pieces all pointed at producers that moved out of the
+bridge in #36 / #111: the activity feed opened an SSE route the bridge never
+served, and every inject action sat for 8 s on a turn stream nothing publishes
+to. Handlers are invoked directly (not via TestClient) so neither CSRF nor a
+live dotty-behaviour is in the path.
+"""
+from __future__ import annotations
+
+import asyncio
+import importlib.util
+import os
+import re
+import sys
+import tempfile
+import unittest
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from starlette.requests import Request
+
+_state_dir = Path(tempfile.mkdtemp(prefix="dotty-feed-state-"))
+os.environ.setdefault("DOTTY_KID_MODE_STATE", str(_state_dir / "kid-mode"))
+os.environ.setdefault("DOTTY_SMART_MODE_STATE", str(_state_dir / "smart-mode"))
+
+_repo_root = Path(__file__).resolve().parents[1]
+_spec = importlib.util.spec_from_file_location("bridge_app", _repo_root / "bridge.py")
+assert _spec is not None and _spec.loader is not None
+bridge_app = importlib.util.module_from_spec(_spec)
+sys.modules["bridge_app"] = bridge_app
+_spec.loader.exec_module(bridge_app)
+
+
+@asynccontextmanager
+async def _noop_lifespan(_app):
+    yield
+
+
+bridge_app.app.router.lifespan_context = _noop_lifespan
+
+import bridge.dashboard as dash  # noqa: E402
+
+
+def _req(path: str = "/ui/perception/feed", method: str = "GET") -> Request:
+    async def _receive():
+        # Never signals http.disconnect — the stream ends on upstream EOF.
+        await asyncio.sleep(3600)
+
+    return Request(
+        {"type": "http", "method": method, "path": path,
+         "headers": [], "query_string": b""},
+        _receive,
+    )
+
+
+class _FakeUpstream:
+    def __init__(self, lines):
+        self._lines = lines
+        self.closed = False
+
+    def iter_lines(self, chunk_size=None):
+        return iter(self._lines)
+
+    def close(self):
+        self.closed = True
+
+
+async def _drain(resp) -> bytes:
+    return b"".join([chunk async for chunk in resp.body_iterator])
+
+
+class _StateSaver(unittest.TestCase):
+    def setUp(self):
+        saved = dict(dash._state)
+        self.addCleanup(lambda: dash._state.update(saved))
+
+
+class PerceptionFeedProxyTests(_StateSaver):
+
+    def test_relays_upstream_lines_and_closes(self):
+        upstream = _FakeUpstream([b'data: {"name":"face_detected"}', b"", b": keepalive", b""])
+        dash._state["perception_feed_opener"] = lambda: upstream
+        resp = asyncio.run(dash.perception_feed_proxy(_req()))
+        self.assertEqual(resp.media_type, "text/event-stream")
+        body = asyncio.run(_drain(resp))
+        self.assertEqual(
+            body,
+            b'retry: 5000\n\ndata: {"name":"face_detected"}\n\n: keepalive\n\n',
+        )
+        self.assertTrue(upstream.closed)
+
+    def test_upstream_down_ends_stream_without_error(self):
+        def _boom():
+            raise ConnectionError("simulated")
+
+        dash._state["perception_feed_opener"] = _boom
+        resp = asyncio.run(dash.perception_feed_proxy(_req()))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(asyncio.run(_drain(resp)), b"retry: 5000\n\n")
+
+    def test_page_subscribes_to_the_relay_route(self):
+        html = (_repo_root / "bridge/templates/dashboard.html").read_text()
+        self.assertIn("new EventSource('/ui/perception/feed')", html)
+        self.assertNotIn("EventSource('/api/perception/feed')", html)
+
+
+class InjectNoWaitTests(_StateSaver):
+
+    def test_returns_without_waiting_for_a_turn(self):
+        async def _inject(text):
+            return {"ok": True}
+
+        dash._state["inject_to_device"] = _inject
+
+        async def _run():
+            return await asyncio.wait_for(
+                dash._inject_or_error(_req("/ui/actions/say", "POST"), "hi", label="hi"),
+                timeout=1.0,
+            )
+
+        body = asyncio.run(_run()).body.decode("utf-8")
+        self.assertIn("sent to Dotty", body)
+        self.assertNotIn("no reply", body)
+
+    def test_inject_failure_surfaces_error(self):
+        async def _inject(text):
+            return {"ok": False, "error": "no device connected"}
+
+        dash._state["inject_to_device"] = _inject
+        resp = asyncio.run(
+            dash._inject_or_error(_req("/ui/actions/say", "POST"), "hi", label="hi")
+        )
+        self.assertIn("no device connected", resp.body.decode("utf-8"))
+
+
+class LastSeenFallbackTests(_StateSaver):
+
+    def setUp(self):
+        super().setUp()
+        dash._state["recent_turns_getter"] = lambda: []
+
+    def test_prefers_newest_reported_turn(self):
+        dash._state["recent_turns_getter"] = lambda: [{"ts": 300.0}, {"ts": 400.0}]
+        dash._state["perception_state_getter"] = lambda: {"dev-1": {"last_chat_t": 100.0}}
+        self.assertEqual(dash._stackchan_last_seen(), 400.0)
+
+    def test_falls_back_to_perception_last_chat(self):
+        dash._state["perception_state_getter"] = lambda: {
+            "dev-1": {"last_chat_t": 100.0}, "dev-2": {"last_chat_t": 250.0},
+        }
+        self.assertEqual(dash._stackchan_last_seen(), 250.0)
+
+    def test_none_when_no_chat_recorded(self):
+        dash._state["perception_state_getter"] = lambda: {"dev-1": {}}
+        self.assertIsNone(dash._stackchan_last_seen())
+
+
+class VoiceToolInventoryTests(unittest.TestCase):
+
+    def test_matches_dotty_pi_ext_tools(self):
+        shipped = set()
+        for src in (_repo_root / "dotty-pi-ext/src/tools").glob("*.ts"):
+            shipped.update(re.findall(r'^\s*name: "(\w+)"', src.read_text(), re.M))
+        self.assertEqual({t["name"] for t in dash._VOICE_TOOLS}, shipped)
+
+
+class VoiceTurnIngestTests(unittest.TestCase):
+    """PiVoiceLLM reports turns to /api/voice/turn; the bridge keeps them in
+    an in-memory ring that feeds /ui/events, the Errors count and report."""
+
+    def setUp(self):
+        from fastapi.testclient import TestClient
+        bridge_app._dashboard_recent_turns.clear()
+        self.addCleanup(bridge_app._dashboard_recent_turns.clear)
+        saved_token = bridge_app._ADMIN_TOKEN
+        self.addCleanup(lambda: setattr(bridge_app, "_ADMIN_TOKEN", saved_token))
+        bridge_app._ADMIN_TOKEN = ""
+        # Each test module loads its own copy of bridge.py, and the shared
+        # bridge.dashboard is wired to whichever loaded last — pin it to ours.
+        saved_getter = dash._state.get("recent_turns_getter")
+        self.addCleanup(lambda: dash._state.update(recent_turns_getter=saved_getter))
+        dash._state["recent_turns_getter"] = bridge_app._dashboard_recent_turns_getter
+        self.client = TestClient(bridge_app.app)
+
+    def test_turn_lands_in_ring_and_reaches_subscribers(self):
+        q = bridge_app._dashboard_subscribe_events()
+        self.addCleanup(lambda: bridge_app._dashboard_unsubscribe_events(q))
+        r = self.client.post("/api/voice/turn", json={
+            "request_text": "hello", "response_text": "😊 Hi!", "latency_ms": 1200,
+        })
+        self.assertEqual(r.status_code, 200)
+        turns = bridge_app._dashboard_recent_turns_getter()
+        self.assertEqual(len(turns), 1)
+        self.assertEqual(turns[0]["request_text"], "hello")
+        self.assertIsNone(turns[0]["error"])
+        self.assertIsInstance(turns[0]["ts"], float)
+        self.assertEqual(q.get_nowait()["response_text"], "😊 Hi!")
+
+    def test_errored_turn_shows_in_count_and_report(self):
+        self.client.post("/api/voice/turn", json={"request_text": "a", "response_text": "ok"})
+        self.client.post("/api/voice/turn", json={
+            "request_text": "what is the weather", "response_text": "😐 (brain offline)",
+            "error": "pi rpc timeout",
+        })
+        self.assertIn("Errors (1)", self.client.get("/ui/alerts/count?chip=1").text)
+        detail = self.client.get("/ui/alerts/detail").text
+        self.assertIn("pi rpc timeout", detail)
+        self.assertIn("what is the weather", detail)
+
+    def test_no_errors_leaves_plain_chip(self):
+        self.client.post("/api/voice/turn", json={"request_text": "a", "response_text": "ok"})
+        self.assertEqual(self.client.get("/ui/alerts/count?chip=1").text, "Errors")
+
+    def test_admin_token_enforced_when_set(self):
+        bridge_app._ADMIN_TOKEN = "s3cret"
+        body = {"request_text": "a", "response_text": "b"}
+        self.assertEqual(self.client.post("/api/voice/turn", json=body).status_code, 401)
+        ok = self.client.post("/api/voice/turn", json=body, headers={"X-Admin-Token": "s3cret"})
+        self.assertEqual(ok.status_code, 200)
+        self.assertEqual(len(bridge_app._dashboard_recent_turns_getter()), 1)
+
+    def test_long_text_is_truncated(self):
+        self.client.post("/api/voice/turn", json={"request_text": "x" * 5000, "response_text": ""})
+        self.assertEqual(len(bridge_app._dashboard_recent_turns_getter()[0]["request_text"]), 2000)
+
+    def test_filter_hit_lands_in_safety_ring(self):
+        import bridge.text as btext
+        btext._cf_recent.clear()
+        self.addCleanup(btext._cf_recent.clear)
+        r = self.client.post("/api/voice/filter-hit", json={
+            "tier": "redirect", "rule": "badword", "prefix": "a longer prefix",
+        })
+        self.assertEqual(r.status_code, 200)
+        hit = btext.recent_content_filter_hits()[0]
+        self.assertEqual((hit["tier"], hit["rule"], hit["prefix"]), ("redirect", "badword", "a longer"))
+        self.assertIn("badword", self.client.get("/ui/safety/recent").text)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_device_command.py b/tests/test_device_command.py
index 07007e9f..e95dd825 100644
--- a/tests/test_device_command.py
+++ b/tests/test_device_command.py
@@ -10,10 +10,11 @@
 import importlib.util as _ilu
 import json
 import pathlib
+import queue
 import sys
 import types
 import unittest
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 _PATCHES = pathlib.Path(__file__).parent.parent / "custom-providers" / "xiaozhi-patches"
 
@@ -231,6 +232,121 @@ def test_resolve_conn_falls_back_to_first_device_and_503s_when_empty(self):
         self.assertIsNone(got)
         self.assertEqual(err.status, 503)
 
+    def test_server_say_survives_chat_sentence_id_change(self):
+        """#104: a chat turn must not invalidate queued server speech."""
+        class SentenceType:
+            FIRST = "first"
+            MIDDLE = "middle"
+            LAST = "last"
+
+        class ContentType:
+            TEXT = "text"
+
+        class DTO:
+            def __init__(self, **kwargs):
+                self.__dict__.update(kwargs)
+
+        dto_module = types.SimpleNamespace(
+            ContentType=ContentType,
+            SentenceType=SentenceType,
+            TTSMessageDTO=DTO,
+        )
+        saved = {
+            name: sys.modules.get(name)
+            for name in (
+                "core.providers", "core.providers.tts",
+                "core.providers.tts.dto", "core.providers.tts.dto.dto",
+            )
+        }
+        try:
+            for name in ("core.providers", "core.providers.tts", "core.providers.tts.dto"):
+                sys.modules[name] = types.ModuleType(name)
+            sys.modules["core.providers.tts.dto.dto"] = dto_module
+
+            async def go():
+                conn = _FakeConn()
+                conn.headers = {"device-id": "dev-say"}
+                conn.tts = types.SimpleNamespace(tts_text_queue=queue.Queue())
+                type(self).active["dev-say"] = conn
+                async def run_inline(func):
+                    return func()
+
+                with patch.object(self.mod.asyncio, "to_thread", side_effect=run_inline):
+                    await self._server()._dotty_say(
+                        self._request({"text": "Hello from the server."})
+                    )
+
+                conn.sentence_id = "new-chat-turn"
+                accepted = []
+                while not conn.tts.tts_text_queue.empty():
+                    message = conn.tts.tts_text_queue.get_nowait()
+                    if (
+                        message.sentence_id != conn.sentence_id
+                        and message.sentence_id not in getattr(
+                            conn, "_dotty_server_push_sentence_ids", set()
+                        )
+                    ):
+                        continue
+                    accepted.append(message)
+
+                self.assertEqual(
+                    [m.sentence_type for m in accepted],
+                    [SentenceType.FIRST, SentenceType.MIDDLE, SentenceType.LAST],
+                )
+
+            asyncio.run(go())
+        finally:
+            for name, module in saved.items():
+                if module is None:
+                    sys.modules.pop(name, None)
+                else:
+                    sys.modules[name] = module
+
+    def test_server_push_exemption_does_not_keep_stale_chat_ids(self):
+        conn = types.SimpleNamespace(
+            sentence_id="current-chat",
+            _dotty_server_push_sentence_ids={"server-push"},
+        )
+
+        def accepted(sentence_id):
+            return not (
+                sentence_id != conn.sentence_id
+                and sentence_id not in conn._dotty_server_push_sentence_ids
+            )
+
+        self.assertFalse(accepted("stale-chat"))
+        self.assertTrue(accepted("server-push"))
+
+    def test_client_abort_still_drops_server_push(self):
+        conn = types.SimpleNamespace(
+            sentence_id="current-chat",
+            client_abort=True,
+            _dotty_server_push_sentence_ids={"server-push"},
+        )
+
+        def accepted(sentence_id):
+            if conn.client_abort:
+                return False
+            return not (
+                sentence_id != conn.sentence_id
+                and sentence_id not in conn._dotty_server_push_sentence_ids
+            )
+
+        self.assertFalse(accepted("server-push"))
+
+    def test_build_patch_rewrites_consumer_predicate_explicitly(self):
+        script = pathlib.Path(__file__).parent.parent / "scripts" / "patch-tts-server-push.py"
+        spec = _ilu.spec_from_file_location("tts_push_patch_under_test", script)
+        module = _ilu.module_from_spec(spec)  # type: ignore[arg-type]
+        spec.loader.exec_module(module)  # type: ignore[union-attr]
+        source = (
+            "if message.sentence_id != self.conn.sentence_id:\n"
+            "                    continue\n"
+        )
+        updated = module.patch_source(source)
+        self.assertIn("_dotty_server_push_sentence_ids", updated)
+        self.assertIn("continue", updated)
+
     def test_no_ms_truncated_ids_left_anywhere(self):
         # The collision-prone id pattern must not reappear in either
         # patch surface (the audit found it at twelve sites).
diff --git a/tests/test_docs_onboarding.py b/tests/test_docs_onboarding.py
new file mode 100644
index 00000000..fcf79f77
--- /dev/null
+++ b/tests/test_docs_onboarding.py
@@ -0,0 +1,84 @@
+"""Regression guards for the documented StackChan provisioning path."""
+
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+ONBOARDING_FILES = (
+    ROOT / "docs" / "quickstart.md",
+    ROOT / "SETUP.md",
+    ROOT / "docs" / "troubleshooting.md",
+    ROOT / "Makefile",
+)
+
+
+def test_docs_do_not_claim_ota_url_is_in_on_device_advanced_options() -> None:
+    combined = "\n".join(path.read_text(encoding="utf-8") for path in ONBOARDING_FILES)
+    stale_directions = (
+        "device's Advanced Options",
+        "robot's Advanced Options",
+        "Settings > Advanced Options",
+    )
+    for stale in stale_directions:
+        assert stale not in combined
+
+
+def test_docs_identify_compiled_ota_url_and_missing_device_editor() -> None:
+    quickstart = (ROOT / "docs" / "quickstart.md").read_text(encoding="utf-8")
+    assert "CONFIG_OTA_URL" in quickstart
+    assert "does **not** contain an Advanced" in quickstart
+    assert "fw-v1.3.3" in quickstart
+
+
+def test_source_build_uses_the_pinned_dotty_firmware_fork() -> None:
+    setup = (ROOT / "SETUP.md").read_text(encoding="utf-8")
+    gitmodules = (ROOT / ".gitmodules").read_text(encoding="utf-8")
+
+    assert "github.com/BrettKinny/StackChan.git" in gitmodules
+    assert "git clone --recursive https://github.com/BrettKinny/dotty-stackchan.git" in setup
+    assert "cd dotty-stackchan/firmware/firmware" in setup
+    assert "git clone https://github.com/m5stack/StackChan.git" not in setup
+
+
+def test_docs_only_recommend_real_firmware_kconfig_symbols() -> None:
+    setup = (ROOT / "SETUP.md").read_text(encoding="utf-8")
+
+    assert "CONFIG_OTA_URL" in setup
+    assert "set `CONFIG_WIFI_SSID`" not in setup
+    assert "set `CONFIG_WIFI_PASSWORD`" not in setup
+    assert "does **not** define `CONFIG_WIFI_SSID`" in setup
+
+
+def test_docs_explain_the_real_first_boot_path() -> None:
+    setup = (ROOT / "SETUP.md").read_text(encoding="utf-8")
+    quickstart = (ROOT / "docs" / "quickstart.md").read_text(encoding="utf-8")
+
+    assert "Skip" in setup
+    assert "Welcome!" in setup
+    assert "Xiaozhi" in setup and "hotspot" in setup.lower()
+    assert "Skip" in quickstart
+
+
+def test_current_docs_do_not_claim_the_firmware_submodule_lacks_state_manager() -> None:
+    current_docs = (
+        (ROOT / "README.md").read_text(encoding="utf-8")
+        + (ROOT / "docs" / "modes.md").read_text(encoding="utf-8")
+        + (ROOT / "CLAUDE.md").read_text(encoding="utf-8")
+    )
+    stale_claims = (
+        "submodule pin in this repo lags",
+        "submodule pin lags",
+        "flashing from the submodule won't give you Phase 4",
+        "does **not** include StateManager",
+        "xiaozhi firmware (built from m5stack/StackChan source)",
+    )
+    for stale in stale_claims:
+        assert stale not in current_docs
+
+
+def test_compatibility_doc_matches_the_current_public_contract() -> None:
+    compatibility = (ROOT / "COMPATIBILITY.md").read_text(encoding="utf-8")
+    assert "`fw-v1.3.3`" in compatibility
+    assert "the seven `dotty-pi-ext` voice tools" in compatibility
+    assert "No formal versioning is adopted yet" not in compatibility
+    assert "scripts/backup.sh" not in compatibility
diff --git a/tests/test_dotty_av_audio_metrics.py b/tests/test_dotty_av_audio_metrics.py
new file mode 100644
index 00000000..7172faed
--- /dev/null
+++ b/tests/test_dotty_av_audio_metrics.py
@@ -0,0 +1,200 @@
+"""Decoded PCM quality checks. AI-assisted: OpenAI Codex (GPT-6)."""
+import importlib.util
+import math
+from pathlib import Path
+import struct
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+
+spec = importlib.util.spec_from_file_location("dotty_av_media", Path(__file__).parents[1] / "scripts/dotty_av_media.py")
+media = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(media)
+
+
+def pcm(values):
+    return struct.pack(f"<{len(values)}f", *values)
+
+
+def test_silent_recording_warns_without_claiming_interaction():
+    result = media.pcm_metrics(pcm([0] * 100))
+    assert result["near_silence"] is True
+    assert result["rms_dbfs"] is None
+    assert result["clipping_ratio"] == 0
+    assert "near_silence" in result["warnings"][0]
+    assert "verdict" not in result and "interaction" not in result
+
+
+def test_known_amplitude_metrics():
+    result = media.pcm_metrics(pcm([.5, -.5] * 100))
+    assert result["rms"] == .5
+    assert result["peak"] == .5
+    assert result["rms_dbfs"] == pytest.approx(-6.0205999)
+    assert result["warnings"] == []
+
+
+def test_severe_clipping_strictly_above_point_one_percent():
+    threshold = media.pcm_metrics(pcm([1.] + [.1] * 999))
+    assert threshold["clipping_ratio"] == .001
+    assert threshold["warnings"] == []
+    severe = media.pcm_metrics(pcm([1., -1.] + [.1] * 998))
+    assert severe["clipping_ratio"] == .002
+    assert "severe_clipping" in severe["warnings"][0]
+
+
+def test_lossy_overshoot_retained_and_explained():
+    result = media.pcm_metrics(pcm([1.1, -1.2]))
+    assert result["peak_dbfs"] > 0
+    assert result["clipped_samples"] == 2
+    assert "Lossy" in result["note"]
+
+
+@pytest.mark.parametrize("data", [b"", b"abc", pcm([math.nan]), pcm([math.inf])])
+def test_rejects_invalid_pcm(data):
+    with pytest.raises(ValueError):
+        media.pcm_metrics(data)
+
+
+def test_decode_is_bounded_and_preserves_channels(monkeypatch):
+    commands = []
+
+    def decode(command, **kwargs):
+        commands.append(command)
+        assert kwargs["timeout"] == 45
+        return pcm([.1, -.1])
+
+    monkeypatch.setattr(media.subprocess, "check_output", decode)
+    result = media.audio_metrics(Path("capture.mp4"))
+    assert commands[0][commands[0].index("-t") + 1] == "180"
+    assert "-ac" not in commands[0] and "-ar" not in commands[0]
+    assert commands[0][-1] == "pipe:1"
+    assert result["analysis_limit_seconds"] == 180
+
+
+def test_native_window_metrics_do_not_downmix_or_resample(monkeypatch):
+    commands = []
+    monkeypatch.setattr(media.subprocess, "check_output",
+                        lambda argv, **kwargs: commands.append(argv) or pcm([1.1, .1]))
+    result = media.audio_metrics(Path("capture.mp4"), start=2, duration=4.5)
+    assert commands[0][commands[0].index("-ss") + 1] == "2"
+    assert commands[0][commands[0].index("-t") + 1] == "4.5"
+    assert "-ac" not in commands[0] and "-ar" not in commands[0]
+    assert result["window_start_seconds"] == 2
+    assert result["analysis_limit_seconds"] == 4.5
+    assert result["clipping_ratio"] == .5
+    assert "verdict" not in result
+
+
+@pytest.mark.parametrize("start, duration", [(-1, 1), (0, 0), (0, 181), (179, 2),
+                                             (math.nan, 2), (0, math.inf), (True, 2)])
+def test_invalid_audio_metric_windows_fail_before_decode(monkeypatch, start, duration):
+    def unexpected(*args, **kwargs):
+        pytest.fail("invalid window reached decoder")
+    monkeypatch.setattr(media.subprocess, "check_output", unexpected)
+    with pytest.raises(ValueError, match="window"):
+        media.audio_metrics("unused", start=start, duration=duration)
+
+
+def test_verify_adds_quality_without_replacing_continuity(monkeypatch):
+    monkeypatch.setattr(media, "probe", lambda _: {"streams": [
+        {"codec_type": "video", "duration": "10", "width": 640, "height": 480},
+        {"codec_type": "audio", "duration": "10", "sample_rate": "48000", "channels": 2}]})
+    monkeypatch.setattr(media, "audio_continuity", lambda *_: {
+        "decoded_seconds": 10, "max_gap_seconds": 0})
+    monkeypatch.setattr(media, "audio_metrics", lambda _: {"near_silence": True, "warnings": ["silent"]})
+    result = media.verify("silent.mp4")
+    assert result["decoded_seconds"] == 10
+    assert result["audio_quality"]["near_silence"]
+    assert "verdict" not in result
+
+
+def test_gain_is_capped_and_peak_limited():
+    quiet = media.pcm_metrics(pcm([.001, -.001] * 100 + [.01]))
+    gain = media.analysis_gain(quiet)
+    assert gain <= 20
+    assert quiet["peak"] * 10 ** (gain / 20) <= 10 ** (-1 / 20) + 1e-6
+    transient = media.pcm_metrics(pcm([.01] * 1000 + [.5]))
+    assert media.analysis_gain(transient) == pytest.approx(-1 - transient["peak_dbfs"])
+    assert media.analysis_gain(media.pcm_metrics(pcm([1., .1]))) == 0
+    assert media.analysis_gain(media.pcm_metrics(pcm([0.] * 100))) == 0
+
+
+def test_analysis_preserves_input_and_records_exact_gain(tmp_path, monkeypatch):
+    source = tmp_path / "original.wav"
+    source.write_bytes(b"original unchanged")
+    decoded = pcm([.02, -.03, .01])
+    monkeypatch.setattr(media.subprocess, "check_output", lambda *a, **kw: decoded)
+    commands = []
+
+    def encode(command, **kwargs):
+        commands.append(command)
+        (tmp_path / "result.analysis.wav").write_bytes(kwargs["input"])
+
+    monkeypatch.setattr(media.subprocess, "run", encode)
+    derivative, record = media.prepare_analysis(source, tmp_path / "result.json")
+    assert source.read_bytes() == b"original unchanged"
+    assert derivative.name == "result.analysis.wav"
+    assert record["gain_db"] > 0
+    assert record["analysis_quality"]["clipped_samples"] == 0
+    assert record["source"] == str(source)
+    assert "-n" in commands[0]
+    with pytest.raises(FileExistsError):
+        media.prepare_analysis(source, tmp_path / "result.json")
+
+
+def test_near_silence_never_invokes_model_or_becomes_pass(tmp_path, monkeypatch):
+    monkeypatch.setattr(media, "prepare_analysis", lambda *_: (
+        tmp_path / "analysis.wav", {"original_quality": {"near_silence": True}}))
+    monkeypatch.setitem(sys.modules, "faster_whisper", SimpleNamespace())
+    result = media.transcribe(tmp_path / "silence.wav", "unused", tmp_path / "out.json", normalize=True)
+    assert result["segments"] == []
+    assert result["evidence_status"] == "INCONCLUSIVE"
+    assert "verdict" not in result
+
+
+@pytest.mark.parametrize("threshold", [None, .3])
+def test_transcript_is_unverified_even_if_noise_hallucinates_text(tmp_path, monkeypatch, threshold):
+    calls = []
+
+    class FakeModel:
+        def __init__(self, *args, **kwargs):
+            assert kwargs["local_files_only"] is True
+
+        def transcribe(self, path, **kwargs):
+            calls.append(kwargs)
+            return [SimpleNamespace(start=1, end=2, text="Thank you for watching",
+                                    no_speech_prob=.2, avg_logprob=-.4, words=[])], SimpleNamespace(language_probability=1)
+
+    monkeypatch.setitem(sys.modules, "faster_whisper", SimpleNamespace(WhisperModel=FakeModel))
+    options = {} if threshold is None else {"vad_threshold": threshold}
+    result = media.transcribe(tmp_path / "noise.wav", "local-model", tmp_path / "out.json", **options)
+    assert calls[0]["vad_filter"] is True
+    assert calls[0]["condition_on_previous_text"] is False
+    assert calls[0]["vad_parameters"] == {"threshold": .5 if threshold is None else threshold}
+    assert result["vad_parameters"] == calls[0]["vad_parameters"]
+    assert "initial_prompt" not in calls[0]
+    assert result["evidence_status"] == "UNVERIFIED_TRANSCRIPT"
+    assert "verdict" not in result
+    with pytest.raises(FileExistsError):
+        media.transcribe(tmp_path / "noise.wav", "local-model", tmp_path / "out.json")
+
+
+@pytest.mark.parametrize("threshold", [-.1, 1.1, math.nan, math.inf, True, None, "invalid"])
+def test_invalid_vad_threshold_is_rejected_before_artifacts(tmp_path, threshold):
+    with pytest.raises(ValueError, match="VAD threshold"):
+        media.transcribe(tmp_path / "source.wav", "unused", tmp_path / "out.json",
+                         normalize=True, vad_threshold=threshold)
+    assert list(tmp_path.iterdir()) == []
+
+
+@pytest.mark.parametrize("threshold", [0, .3, .5, 1])
+def test_silent_normalized_provenance_preserves_valid_threshold(tmp_path, monkeypatch, threshold):
+    monkeypatch.setattr(media, "prepare_analysis", lambda *_: (
+        tmp_path / "analysis.wav", {"original_quality": {"near_silence": True}}))
+    result = media.transcribe(tmp_path / "source.wav", "unused", tmp_path / "out.json",
+                              normalize=True, vad_threshold=threshold)
+    assert result["evidence_status"] == "INCONCLUSIVE"
+    assert result["segments"] == []
+    assert result["vad_parameters"] == {"threshold": float(threshold)}
diff --git a/tests/test_dotty_av_capture.py b/tests/test_dotty_av_capture.py
new file mode 100644
index 00000000..80249ad0
--- /dev/null
+++ b/tests/test_dotty_av_capture.py
@@ -0,0 +1,149 @@
+"""Capture failure must never trigger speaker playback (Codex GPT-6 assisted)."""
+import importlib.util
+import os
+from pathlib import Path
+import subprocess
+import shutil
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location("media", ROOT / "scripts/dotty_av_media.py")
+media = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(media)
+
+
+@pytest.mark.parametrize("streams", [[], [{"codec_type": "video", "duration": "1"}],
+    [{"codec_type": "video", "duration": "nan"}, {"codec_type": "audio", "duration": "1"}],
+    [{"codec_type": "video", "duration": "5"}, {"codec_type": "audio", "duration": "1"}]])
+def test_invalid_streams_rejected(monkeypatch, streams):
+    monkeypatch.setattr(media, "probe", lambda _: {"streams": streams})
+    with pytest.raises(ValueError):
+        media.verify("unused")
+
+
+def test_complete_but_truncated_capture_rejected(monkeypatch):
+    monkeypatch.setattr(media, "probe", lambda _: {"streams": [
+        {"codec_type": "video", "duration": "5", "width": 1280, "height": 720},
+        {"codec_type": "audio", "duration": "5", "sample_rate": "32000", "channels": 2}]})
+    with pytest.raises(ValueError, match="truncated"):
+        media.verify("unused", expected=30)
+
+
+def test_timestamp_stretched_audio_rejected(monkeypatch):
+    monkeypatch.setattr(media, "probe", lambda _: {"streams": [
+        {"codec_type": "video", "duration": "36", "width": 1280, "height": 720},
+        {"codec_type": "audio", "duration": "36", "sample_rate": "32000", "channels": 2}]})
+    monkeypatch.setattr(media, "audio_continuity", lambda *_: {
+        "decoded_seconds": 2.14, "decoded_samples": 68544, "max_gap_seconds": 2.3})
+    with pytest.raises(ValueError, match="audio sample loss"):
+        media.verify("unused")
+
+
+def test_failed_camera_prevents_speaker_playback(tmp_path):
+    binaries = tmp_path / "bin"
+    binaries.mkdir()
+    programs = {
+        "pactl": "echo test-sink",
+        "espeak-ng": 'while [ "$1" != "-w" ]; do shift; done; shift; printf speech > "$1"',
+        "ffprobe": "echo 2",
+        "ffmpeg": "exit 42",
+        "pw-play": f'touch "{tmp_path / "PLAYED"}"',
+    }
+    for name, body in programs.items():
+        path = binaries / name
+        path.write_text("#!/bin/sh\n" + body + "\n")
+        path.chmod(0o755)
+    result = subprocess.run(["bash", ROOT / "scripts/dotty-av-test.sh", "run", "hello", "5", tmp_path / "capture.mp4"],
+        env={**os.environ, "PATH": str(binaries) + ":" + os.environ["PATH"],
+             "XDG_RUNTIME_DIR": str(tmp_path), "DOTTY_AV_VOLUME": "20"},
+        capture_output=True, text=True, timeout=10)
+    assert result.returncode != 0
+    assert "capture failed before playback" in result.stderr
+    assert not (tmp_path / "PLAYED").exists()
+
+
+def test_unbounded_recording_rejected(tmp_path):
+    result = subprocess.run(["bash", ROOT / "scripts/dotty-av-test.sh", "record", "181", tmp_path / "capture.mp4"],
+                            capture_output=True, text=True, timeout=5)
+    assert result.returncode != 0
+    assert not (tmp_path / "capture.mp4").exists()
+
+
+def capture_function(name, *args, lossless="1", backend="pulse"):
+    # Load definitions only: no command dispatch, devices, or playback.
+    definitions = (ROOT / "scripts/dotty-av-test.sh").read_text().split('\ncmd=', 1)[0]
+    return subprocess.run(["bash", "-c", 'source /dev/stdin; "$@"', "fixture", name,
+                           *map(str, args)], input=definitions, capture_output=True, text=True, timeout=5,
+                          env={**os.environ, "DOTTY_AV_LOSSLESS_AUDIO": lossless,
+                               "DOTTY_AV_AUDIO_BACKEND": backend})
+
+
+def test_lossless_sidecar_maps_same_audio_and_bounds_each_output(tmp_path):
+    output = tmp_path / "unique-case.mp4"
+    result = capture_function("capture_output_args", "7", output)
+    assert result.returncode == 0, result.stderr
+    argv = result.stdout.splitlines()
+    split = argv.index(str(output))
+    mp4, wav = argv[:split], argv[split + 1:]
+    assert mp4[mp4.index("-t") + 1] == "7"
+    assert wav[wav.index("-t") + 1] == "7"
+    assert mp4[:4] == ["-map", "0:v:0", "-map", "1:a:0"]
+    assert wav[:2] == ["-map", "1:a:0"]
+    assert wav[wav.index("-c:a") + 1] == "pcm_f32le"
+    assert wav[wav.index("-ar") + 1] == "32000"
+    assert wav[wav.index("-ac") + 1] == "2"
+    assert wav[-1] == str(output.with_suffix(".capture.wav"))
+
+
+def test_default_capture_has_no_lossless_output_or_float_input(tmp_path):
+    result = capture_function("capture_output_args", "7", tmp_path / "default.mp4", lossless="0")
+    assert result.returncode == 0, result.stderr
+    assert ".capture.wav" not in result.stdout and "pcm_f32le" not in result.stdout
+    inputs = capture_function("capture_args", lossless="0")
+    assert "pcm_f32le" not in inputs.stdout
+
+
+def test_opt_in_pulse_requests_float_before_reading_input():
+    result = capture_function("capture_args")
+    argv = result.stdout.splitlines()
+    pulse = argv.index("pulse")
+    assert argv.index("pcm_f32le") > pulse
+    assert argv.index("pcm_f32le") < len(argv) - 2  # before final -i source
+    assert "pcm_f32le" not in capture_function("capture_args", backend="alsa").stdout
+
+
+@pytest.mark.parametrize("kind", ["record", "run"])
+def test_existing_sidecar_is_never_overwritten_or_played(tmp_path, kind):
+    sidecar = tmp_path / "capture.capture.wav"
+    sidecar.write_bytes(b"existing evidence")
+    argv = ["bash", ROOT / "scripts/dotty-av-test.sh", kind]
+    if kind == "run":
+        argv.append("fixture no playback")
+    argv.extend(["5", tmp_path / "capture.mp4"])
+    result = subprocess.run(argv, capture_output=True, text=True, timeout=5,
+                            env={**os.environ, "DOTTY_AV_LOSSLESS_AUDIO": "1"})
+    assert result.returncode != 0
+    assert "output already exists" in result.stderr
+    assert sidecar.read_bytes() == b"existing evidence"
+    assert not (tmp_path / "capture.mp4").exists()
+
+
+def test_same_process_synthetic_float_sidecar_preserves_overshoots(tmp_path):
+    if not shutil.which("ffmpeg") or not shutil.which("ffprobe"):
+        pytest.skip("FFmpeg unavailable")
+    output = tmp_path / "synthetic.mp4"
+    rendered = capture_function("capture_output_args", "1", output)
+    assert rendered.returncode == 0, rendered.stderr
+    subprocess.run(["ffmpeg", "-nostdin", "-n", "-v", "error",
+                    "-f", "lavfi", "-i", "color=size=160x120:rate=10",
+                    "-f", "lavfi", "-i", "aevalsrc=1.05*sin(2*PI*440*t)|0.2*sin(2*PI*660*t):s=32000",
+                    *rendered.stdout.splitlines()], check=True, capture_output=True, timeout=15)
+    sidecar = output.with_suffix(".capture.wav")
+    streams = media.probe(sidecar)["streams"]
+    assert len(streams) == 1
+    assert streams[0]["codec_name"] == "pcm_f32le"
+    assert streams[0]["channels"] == 2 and streams[0]["sample_rate"] == "32000"
+    assert float(streams[0]["duration"]) == pytest.approx(1, abs=.01)
+    assert media.audio_metrics(sidecar)["peak"] > 1.04
+    assert media.verify(output)["audio_seconds"] == pytest.approx(1, abs=.05)
diff --git a/tests/test_dotty_av_clips.py b/tests/test_dotty_av_clips.py
new file mode 100644
index 00000000..6dba059b
--- /dev/null
+++ b/tests/test_dotty_av_clips.py
@@ -0,0 +1,142 @@
+"""Clip provenance regression checks. AI-assisted: OpenAI Codex (GPT-6)."""
+import importlib.util
+import json
+from pathlib import Path
+import shutil
+from types import SimpleNamespace
+
+import pytest
+
+
+spec = importlib.util.spec_from_file_location("dotty_av_clips", Path(__file__).parents[1] / "scripts/dotty_av_clips.py")
+clips = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(clips)
+
+
+@pytest.fixture
+def case(tmp_path, monkeypatch):
+    folder = tmp_path / "cases" / "funny-1"
+    folder.mkdir(parents=True)
+    (folder / "raw.mp4").write_bytes(b"original evidence")
+    (folder / "result.json").write_text(json.dumps({
+        "verdict": "PASS", "commit": "abc123", "response_offset": 8,
+        "started": "2026-09-12T23:59:59+10:00", "case": {"prompt": "<Hello>"}}))
+    (folder / "response.json").write_text(json.dumps({"segments": [
+        {"start": 2, "end": 4, "text": " Hello there! "}]}))
+    monkeypatch.setattr(clips, "media_duration", lambda _: 30)
+    commands = []
+    monkeypatch.setattr(clips, "execute", lambda command: commands.append(command) or SimpleNamespace(stdout=""))
+    return tmp_path, folder, commands
+
+
+def test_captions_align_response_then_trim():
+    srt, cues = clips.captions({"segments": [{"start": 2, "end": 6, "text": "Test"}]}, 8, 11, 13)
+    assert "00:00:00,000 --> 00:00:02,000" in srt
+    assert cues[0]["source_start"] == 10
+    assert cues[0]["source_end"] == 14
+
+
+@pytest.mark.parametrize("name", ["../other", "/tmp/video", "foo/bar", "", "a\\b"])
+def test_reject_path_identifiers(name):
+    with pytest.raises(ValueError):
+        clips.identifier(name)
+
+
+def test_export_preserves_source_and_defaults_to_review(case):
+    session, folder, commands = case
+    destination = clips.export(session, "funny-1", name="take-one", start=9, end=14)
+    assert destination.parent.name == "needs-review"
+    assert (folder / "raw.mp4").read_bytes() == b"original evidence"
+    manifest = clips.load(destination / "manifest.json")
+    assert manifest["source"]["start_seconds"] == 9
+    assert manifest["source"]["case_started"] == "2026-09-12T23:59:59+10:00"
+    assert manifest["commit"] == "abc123"
+    assert manifest["captions"]["state"] == "provisional"
+    assert "00:00:01,000 --> 00:00:03,000" in (destination / "captions.srt").read_text()
+    assert all("-n" in command for command in commands)
+    assert "&lt;Hello&gt;" in (destination / "index.html").read_text()
+    with pytest.raises(FileExistsError):
+        clips.export(session, "funny-1", name="take-one", start=9, end=14)
+    assert len(commands) == 2
+
+
+def test_case_symlink_cannot_escape_session(case, tmp_path):
+    session, _, _ = case
+    (session / "cases" / "escape").symlink_to(session.parent)
+    with pytest.raises(ValueError, match="escapes"):
+        clips.export(session, "escape")
+
+
+@pytest.mark.parametrize("start,end", [(-1, 2), (5, 4), (0, 31), (float("nan"), 10)])
+def test_invalid_intervals_create_no_export(case, start, end):
+    session, _, _ = case
+    with pytest.raises(ValueError):
+        clips.export(session, "funny-1", start=start, end=end)
+    assert not (session / "clips").exists()
+
+
+def test_failed_test_stays_labelled_even_with_review_gates(case):
+    session, folder, _ = case
+    result = clips.load(folder / "result.json")
+    result["verdict"] = "FAIL"
+    (folder / "result.json").write_text(json.dumps(result))
+    destination = clips.export(session, "funny-1", reviewed=clips.GATES)
+    assert destination.parent.name == "failures"
+
+
+def test_missing_response_offset_does_not_guess_caption_timing(case):
+    session, folder, _ = case
+    result = clips.load(folder / "result.json")
+    del result["response_offset"]
+    (folder / "result.json").write_text(json.dumps(result))
+    destination = clips.export(session, "funny-1")
+    assert not (destination / "captions.srt").exists()
+    assert "missing response_offset" in clips.load(destination / "manifest.json")["captions"]["state"]
+
+
+def test_index_is_new_snapshot_and_local_links(case):
+    session, _, _ = case
+    clips.export(session, "funny-1")
+    first, second = clips.index(session), clips.index(session)
+    assert first != second and first.exists() and second.exists()
+    assert "../cases/funny-1/raw.mp4" in first.read_text()
+
+
+@pytest.mark.skipif(not shutil.which("ffmpeg") or not shutil.which("ffprobe"), reason="FFmpeg unavailable")
+def test_synthetic_media_round_trip(tmp_path):
+    folder = tmp_path / "cases" / "synthetic"
+    folder.mkdir(parents=True)
+    # Generated patterns and tone only: no household media, microphone or speaker.
+    clips.execute(["ffmpeg", "-nostdin", "-n", "-v", "error", "-f", "lavfi", "-i",
+                   "color=c=blue:s=320x240:r=10:d=2", "-f", "lavfi", "-i",
+                   "sine=frequency=440:duration=2", "-c:v", "libx264", "-pix_fmt", "yuv420p",
+                   "-c:a", "aac", "-shortest", str(folder / "raw.mp4")])
+    (folder / "result.json").write_text(json.dumps({"verdict": "INCONCLUSIVE"}))
+    destination = clips.export(tmp_path, "synthetic")
+    assert clips.media_duration(destination / "clean.mp4") == pytest.approx(2, abs=.2)
+    streams = json.loads(clips.execute(["ffprobe", "-v", "error", "-show_streams", "-of", "json",
+                                        str(destination / "clean.mp4")]).stdout)["streams"]
+    video = next(s for s in streams if s["codec_type"] == "video")
+    assert (video["width"], video["height"]) == (1080, 1920)
+    assert (destination / "thumbnail.jpg").stat().st_size > 0
+
+
+# --- vertical crop for Shorts framing. AI-assisted: Claude. ---
+
+def test_crop_fills_the_vertical_frame_and_is_recorded(case):
+    session, _folder, commands = case
+    destination = clips.export(session, "funny-1", name="cropped", start=9, end=14, crop="405:720:368:0")
+    video_filter = commands[0][commands[0].index("-vf") + 1]
+    assert video_filter.startswith("crop=405:720:368:0,scale=1080:1920")
+    assert "pad=" not in video_filter
+    manifest = clips.load(destination / "manifest.json")
+    assert manifest["layout"] == "1080x1920 cropped from source region 405:720:368:0"
+
+
+@pytest.mark.parametrize("crop", ["405x720", "405:720:368", "0:720:0:0", "720:405:0:0", "a:b:c:d", "405:720:-1:0"])
+def test_crop_must_be_a_portrait_source_region(case, crop):
+    session, _folder, commands = case
+    with pytest.raises(ValueError):
+        clips.export(session, "funny-1", name="bad-crop", start=9, end=14, crop=crop)
+    assert commands == []
+    assert not list((session / "clips").glob("*/bad-crop"))
diff --git a/tests/test_dotty_overnight.py b/tests/test_dotty_overnight.py
new file mode 100644
index 00000000..3d554dea
--- /dev/null
+++ b/tests/test_dotty_overnight.py
@@ -0,0 +1,745 @@
+"""Evidence and crash-safety regression tests. AI-assisted: OpenAI Codex (GPT-6)."""
+import importlib.util
+import hashlib
+import json
+from pathlib import Path
+import sys
+
+import pytest
+
+SCRIPTS = Path(__file__).resolve().parents[1] / "scripts"
+sys.path.insert(0, str(SCRIPTS))
+spec = importlib.util.spec_from_file_location("dotty_overnight", SCRIPTS / "dotty_overnight.py")
+runner = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(runner)
+
+
+def after(**state):
+    return {"errors": {}, "services_running": True, "perception": {"robot": {
+        "sensor_stale": False, "current_state": "idle", "listening": False,
+        "sensor_age_s": 0, "last_event_t": 1000, "last_chat_status_t": 1000, **state}}}
+
+
+def transcript(text):
+    return {"segments": [{"text": text, "start": 0, "end": 2,
+                           "no_speech_prob": .01, "avg_logprob": -.1}]}
+
+
+def test_substring_is_not_correct_answer():
+    assert not runner.matches("I know the answer", [["no"]])
+    assert runner.matches("No, not necessarily.", [["no"]])
+
+
+@pytest.mark.parametrize("speech,logs,failure", [
+    ({"segments": []}, "结果: name\nSentenceType.FIRST", "response_transcription_unavailable"),
+    (transcript("Dotty"), "", "no_asr_or_no_wake"),
+    (transcript("Dotty"), "结果: name", "no_tts"),
+    (transcript("other"), "结果: name\nSentenceType.FIRST", "response_mismatch"),
+])
+def test_independent_evidence_required(speech, logs, failure):
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, speech,
+                             logs, 10, after(), "robot")
+    assert result["failure"] == failure
+    assert result["verdict"] == ("INCONCLUSIVE" if failure == "response_transcription_unavailable" else "FAIL")
+
+
+def test_no_visual_evidence_means_no_overall_pass():
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, transcript("Dotty"),
+                             "结果: name\nSentenceType.FIRST", 10, after(), "robot")
+    assert result["interaction"] == "PASS"
+    assert result["verdict"] == "INCONCLUSIVE"
+
+
+@pytest.mark.parametrize("state", [after(current_state="talk", listening=True), after()])
+def test_ready_for_followup_accepts_ended_tts_and_fresh_resting_state(state):
+    result = runner.evaluate({"recovery_policy": "ready_for_followup", "reply": [["Dotty"]]},
+                             transcript("Dotty"), "结果: name\nSentenceType.FIRST\nSentenceType.LAST",
+                             10, state, "robot")
+    assert result["recovery"] == "PASS"
+    assert result["interaction"] == "PASS"
+    assert result["verdict"] == "INCONCLUSIVE"
+
+
+@pytest.mark.parametrize("logs", ["SentenceType.FIRST", "SentenceType.LAST\nSentenceType.FIRST",
+                                  "SentenceType.LAST\n发送第一段语音:"])
+def test_ready_for_followup_rejects_missing_or_prior_turn_last(logs):
+    result = runner.evaluate({"recovery_policy": "ready_for_followup"}, transcript("Dotty"),
+                             "结果: name\n" + logs, 10,
+                             after(current_state="talk", listening=True), "robot")
+    assert result["recovery"] == "FAIL"
+    assert result["failure"] == "not_ready_for_followup"
+
+
+@pytest.mark.parametrize("state", [
+    after(current_state="talk", listening=False),
+    after(current_state="idle", listening=True),
+    after(current_state="sleep", listening=False),
+    after(sensor_stale=True),
+    {**after(), "services_running": False},
+    {**after(), "errors": {"bridge": "unavailable"}},
+])
+def test_ready_for_followup_rejects_unhealthy_or_wrong_state(state):
+    result = runner.evaluate({"recovery_policy": "ready_for_followup"}, transcript("Dotty"),
+                             "结果: name\nSentenceType.FIRST\nSentenceType.LAST", 10, state, "robot")
+    assert result["recovery"] == "FAIL"
+
+
+def test_tool_requires_concrete_call_marker_not_spoken_name():
+    result = runner.evaluate({"expected_tool": "think_hard"}, transcript("I used think_hard"),
+                             "结果: please use think_hard\nSentenceType.FIRST", 10, after(), "robot")
+    assert result["expected_tool_call"] == "INCONCLUSIVE"
+    assert result["interaction"] == "INCONCLUSIVE"
+    assert result["verdict"] == "INCONCLUSIVE"
+
+
+def test_tool_marker_is_exact_and_does_not_prove_execution():
+    logs = "结果: think\nSentenceType.FIRST\nPiClient: tool call name=think_hard id=call_123"
+    result = runner.evaluate({"expected_tool": "think_hard"}, transcript("No"), logs, 10, after(), "robot")
+    assert result["expected_tool_call"] == "PASS"
+    assert result["tool_execution"] == "INCONCLUSIVE"
+    other = runner.evaluate({"expected_tool": "think"}, transcript("No"), logs, 10, after(), "robot")
+    assert other["expected_tool_call"] == "INCONCLUSIVE"
+
+
+def test_missing_tool_marker_and_words_cannot_establish_silence():
+    result = runner.evaluate({"expected_tool": "think_hard"}, {"segments": []},
+                             "结果: think\nSentenceType.FIRST", 10, after(), "robot")
+    assert result["failure"] == "response_transcription_unavailable"
+    assert result["interaction"] == "INCONCLUSIVE"
+
+
+def test_response_word_limit_is_strict_without_asserting_creative_quality():
+    logs = "结果: joke\nSentenceType.FIRST"
+    result = runner.evaluate({"max_response_words": 3}, transcript("I'm a robot"), logs, 10, after(), "robot")
+    assert result["response_word_count"] == 3
+    assert result["response_length"] == "PASS"
+    assert result["semantic_quality"] == "INCONCLUSIVE"
+    assert result["verdict"] == "INCONCLUSIVE"
+    longer = runner.evaluate({"max_response_words": 3}, transcript("I'm a tiny robot"), logs, 10, after(), "robot")
+    assert longer["response_word_count"] == 4
+    assert longer["failure"] == "response_too_long"
+    assert longer["verdict"] == "FAIL"
+
+
+@pytest.mark.parametrize("limit", [0, -1, True, "3", 3.5])
+def test_invalid_word_limit_is_rejected(limit):
+    with pytest.raises(ValueError, match="positive integer"):
+        runner.evaluate({"max_response_words": limit}, transcript("hello"),
+                        "结果: hello\nSentenceType.FIRST", 10, after(), "robot")
+
+
+def test_emoji_stripped_tts_does_not_imply_bad_expression():
+    result = runner.evaluate({}, transcript("Dotty"), "结果: name\n发送第一段语音: Dotty",
+                             10, after(), "robot")
+    assert result["expression"] == "INCONCLUSIVE"
+    assert result["visual"] == "INCONCLUSIVE"
+
+
+def receive_frame(frame):
+    return ("260912 22:24:45[0.9.3_SiWhPiLononoCh][core.handle.textMessageProcessor]-INFO-收到"
+            + frame["type"] + "消息：" + json.dumps(frame))
+
+
+@pytest.mark.parametrize("frame", [
+    {"session_id": "fixture", "type": "listen", "state": "detect", "text": "Hi ESP"},
+    {"type": "event", "name": "wake_word_detected", "data": {"phrase": "Hi ESP"}},
+])
+def test_real_received_wake_frame_proves_wake_with_idle_precondition(frame):
+    before = {**after(), "devices": ["robot"]}
+    result = runner.evaluate({"require_wake_event": True}, transcript("Dotty"),
+                             receive_frame(frame) + "\n结果: name\nSentenceType.FIRST",
+                             10, after(), "robot", before=before)
+    assert result["wake_event"] == "PASS"
+    assert result["wake_precondition"] == "PASS"
+    assert result["interaction"] == "PASS"
+
+
+@pytest.mark.parametrize("false_evidence", [
+    receive_frame({"type": "listen", "state": "start", "mode": "auto"}),
+    receive_frame({"type": "event", "name": "state_changed", "data": {"state": "talk"}}),
+    '结果: {"type":"listen","state":"detect"}',
+    'wake_word_detected',
+    'PiClient: text wake_word_detected',
+    '[core.handle.textMessageProcessor]-INFO-收到listen消息：{"type":"event","name":"wake_word_detected"}',
+    '[core.handle.textMessageProcessor]-INFO-收到listen消息：{bad json}',
+])
+def test_existing_listening_or_keyword_mentions_do_not_prove_wake(false_evidence):
+    result = runner.evaluate({"require_wake_event": True}, transcript("Dotty"),
+                             false_evidence + "\n结果: name\nSentenceType.FIRST", 10, after(), "robot",
+                             before={**after(), "devices": ["robot"]})
+    assert result["failure"] == "no_wake_event"
+    assert result["interaction"] == "FAIL"
+
+
+@pytest.mark.parametrize("before", [
+    None,
+    {**after(current_state="talk", listening=True), "devices": ["robot"]},
+    {**after(sensor_stale=True), "devices": ["robot"]},
+    {**after(), "devices": ["robot", "other"]},
+])
+def test_absent_wake_precondition_blocks_even_if_wake_frame_seen(before):
+    result = runner.evaluate({"require_wake_event": True}, transcript("Dotty"),
+                             receive_frame({"type": "listen", "state": "detect"})
+                             + "\n结果: name\nSentenceType.FIRST", 10, after(), "robot", before=before)
+    assert result["verdict"] == "BLOCKED"
+    assert result["failure"] == "wake_precondition"
+
+
+def test_warm_followup_does_not_require_cold_wake():
+    result = runner.evaluate({"recovery_policy": "ready_for_followup"}, transcript("Dotty"),
+                             "结果: name\nSentenceType.FIRST\nSentenceType.LAST", 10,
+                             after(current_state="talk", listening=True), "robot",
+                             before={**after(current_state="talk", listening=True), "devices": ["robot"]})
+    assert result["interaction"] == "PASS"
+    assert result["wake_event"] == "NOT_REQUIRED"
+
+
+def test_run_case_blocks_before_playback_without_changing_robot(tmp_path, monkeypatch):
+    commands = []
+    def fake_command(argv, **kwargs):
+        commands.append(argv)
+        assert argv == ["git", "rev-parse", "HEAD"]
+        return "fixture-commit\n"
+    monkeypatch.setattr(runner, "command", fake_command)
+    monkeypatch.setattr(runner, "snapshot", lambda host: {
+        **after(current_state="talk", listening=True), "devices": ["robot"]})
+    result = runner.run_case(tmp_path, {"host": "unused", "device": "robot"},
+                             {"id": "wake", "require_wake_event": True})
+    assert result["verdict"] == "BLOCKED"
+    assert result["failure"] == "wake_precondition"
+    assert result["capture"] == "INCONCLUSIVE"
+    assert len(commands) == 1
+
+
+@pytest.fixture
+def prompt_capture_boundary(monkeypatch):
+    """Stop at the subprocess boundary; never touch real playback or hardware."""
+    captured = []
+    def fake_command(argv, **kwargs):
+        if argv == ["git", "rev-parse", "HEAD"]:
+            return "fixture-commit\n"
+        return {("pactl", "get-default-sink"): "fixture-speaker\n",
+                ("pactl", "get-sink-volume", "fixture-speaker"): "Volume: 35%\n",
+                ("pactl", "get-sink-mute", "fixture-speaker"): "Mute: no\n"}[tuple(argv)]
+    def capture(argv, log, session, timeout, env, deadline):
+        captured.append({"argv": argv, "env": env,
+                         "evidence_at_launch": json.loads((Path(log).parent / "result.json").read_text())})
+        raise RuntimeError("fixture_capture_stop")
+    monkeypatch.setattr(runner, "command", fake_command)
+    monkeypatch.setattr(runner, "snapshot", lambda host: {**after(), "devices": ["robot"]})
+    monkeypatch.setattr(runner, "host_clock", lambda host: {"offset_seconds": 0, "uncertainty_seconds": 0})
+    monkeypatch.setattr(runner, "guarded_process", capture)
+    return {"host": "unused", "device": "robot", "sink": "fixture-speaker", "volume": 35,
+            "stop_prompts_at": "2099-01-01T00:00:00+00:00"}, captured
+
+
+def test_explicit_warm_state_case_blocks_before_capture_when_idle(tmp_path, prompt_capture_boundary):
+    config, captured = prompt_capture_boundary
+    result = runner.run_case(tmp_path, config, {"id": "sleep", "prompt": "Go to sleep.",
+                                               "require_warm_listening": True})
+    assert result["verdict"] == "BLOCKED"
+    assert result["failure"] == "warm_listening_precondition"
+    assert result["warm_listening_precondition"] == "BLOCKED"
+    assert result["capture"] == "INCONCLUSIVE"
+    assert captured == []
+
+
+def test_fresh_state_event_cannot_revalidate_old_listening_status(
+        tmp_path, monkeypatch, prompt_capture_boundary):
+    config, captured = prompt_capture_boundary
+    monkeypatch.setattr(runner, "snapshot", lambda host: {
+        **after(current_state="idle", listening=True, last_event_t=1500,
+                last_chat_status_t=1000, sensor_age_s=1), "devices": ["robot"]})
+    result = runner.run_case(tmp_path, config, {"id": "sleep", "prompt": "Go to sleep.",
+                                               "require_warm_listening": True})
+    assert result["verdict"] == "BLOCKED"
+    assert result["failure"] == "warm_listening_precondition"
+    assert result["warm_listening_status_age_seconds"] == 501
+    assert captured == []
+
+
+@pytest.mark.parametrize("state", ["idle", "talk", "story_time"])
+def test_explicit_warm_precondition_requires_listening_not_talk_state(
+        tmp_path, monkeypatch, prompt_capture_boundary, state):
+    config, captured = prompt_capture_boundary
+    monkeypatch.setattr(runner, "snapshot", lambda host: {
+        **after(current_state=state, listening=True), "devices": ["robot"]})
+    result = runner.run_case(tmp_path, config, {"id": "sleep", "prompt": "Go to sleep.",
+                                               "require_warm_listening": True})
+    assert result["failure"] == "fixture_capture_stop"
+    assert result["warm_listening_precondition"] == "PASS"
+    assert len(captured) == 1
+
+
+def test_window_metrics_keep_prompt_and_response_separate_without_verdict(tmp_path, monkeypatch):
+    media = tmp_path / "raw.mp4"
+    sidecar = tmp_path / "raw.capture.wav"
+    sidecar.write_bytes(b"fixture")
+    calls = []
+    def metrics(path, start, duration):
+        calls.append((Path(path).name, start, duration))
+        return {"clipping_ratio": .006 if start == 0 else 0,
+                "channel_policy": "native; no downmix or resampling"}
+    monkeypatch.setattr(runner, "audio_metrics", metrics)
+    result = runner.capture_window_metrics(media, 53, 6.4, 6.8)
+    assert calls == [("raw.mp4", 0, 6.4), ("raw.mp4", 6.8, 46.2),
+                     ("raw.capture.wav", 0, 6.4), ("raw.capture.wav", 6.8, 46.2)]
+    assert result["container_audio"]["prompt"]["clipping_ratio"] == .006
+    assert result["container_audio"]["response"]["clipping_ratio"] == 0
+    assert result["lossless_capture"]["source"] == str(sidecar)
+    assert "verdict" not in result and "interaction" not in result
+    assert "not sample-aligned" in result["timing_note"]
+
+
+@pytest.mark.parametrize("mapping", [None, {}, {"other-case": {"path": "/unrelated/prompt.wav"}}])
+def test_unconfigured_case_cannot_inherit_another_prompt_wav(tmp_path, monkeypatch, prompt_capture_boundary, mapping):
+    config, captured = prompt_capture_boundary
+    if mapping is not None:
+        config["prompt_wavs"] = mapping
+    monkeypatch.setenv("DOTTY_AV_PROMPT_WAV", "/unrelated/prompt.wav")
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": "Twelve plus seven?"})
+    assert result["failure"] == "fixture_capture_stop"
+    assert "DOTTY_AV_PROMPT_WAV" not in captured[0]["env"]
+    assert result["prompt_provenance"] == {"source": "harness_default", "renderer": "espeak-ng",
+                                             "text": "Twelve plus seven?"}
+
+
+@pytest.mark.parametrize("relative", [False, True])
+def test_configured_prompt_is_bound_to_case_and_persisted_before_capture(tmp_path, monkeypatch, prompt_capture_boundary, relative):
+    config, captured = prompt_capture_boundary
+    wav = tmp_path / "original.wav"
+    wav.write_bytes(b"fixture waveform bytes")
+    entry = {"path": wav.name if relative else str(wav), "text": "Twelve plus seven?",
+             "sha256": hashlib.sha256(wav.read_bytes()).hexdigest(), "renderer": "local Piper fixture"}
+    config["prompt_wavs"] = {"arithmetic": entry}
+    monkeypatch.setenv("DOTTY_AV_PROMPT_WAV", "/unrelated/prompt.wav")
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": entry["text"]})
+    assert result["failure"] == "fixture_capture_stop"
+    selected = Path(captured[0]["env"]["DOTTY_AV_PROMPT_WAV"])
+    assert selected != wav  # Freeze per-attempt evidence against later source edits.
+    assert selected.read_bytes() == wav.read_bytes()
+    assert result["prompt_provenance"] == {**entry, "source_path": str(wav),
+                                             "path": str(selected), "source": "configured_wav"}
+    assert captured[0]["evidence_at_launch"]["prompt_provenance"] == result["prompt_provenance"]
+    wav.write_bytes(b"later replacement waveform")
+    assert hashlib.sha256(selected.read_bytes()).hexdigest() == entry["sha256"]
+
+
+@pytest.mark.parametrize("replacement, failure", [
+    ({"text": "Twelve plus ten?"}, "prompt_wav_text_mismatch"),
+    ({"text": "Twelve plus seven? "}, "prompt_wav_text_mismatch"),
+    ({"sha256": "0" * 64}, "prompt_wav_sha256_mismatch"),
+])
+def test_mismatched_prompt_cannot_reach_capture(tmp_path, prompt_capture_boundary, replacement, failure):
+    config, captured = prompt_capture_boundary
+    wav = tmp_path / "prompt.wav"
+    wav.write_bytes(b"fixture waveform bytes")
+    config["prompt_wavs"] = {"arithmetic": {
+        "path": str(wav), "text": "Twelve plus seven?",
+        "sha256": hashlib.sha256(wav.read_bytes()).hexdigest(), "renderer": "fixture", **replacement}}
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": "Twelve plus seven?"})
+    assert result["failure"] == failure
+    assert result["capture"] == "INCONCLUSIVE"
+    assert captured == []
+
+
+@pytest.mark.parametrize("defect", ["missing_file", "empty_file", "path", "text", "sha256", "renderer",
+                                    "blank_renderer", "invalid_hash", "entry_not_object", "map_not_object"])
+def test_invalid_prompt_manifest_rejected_before_capture(tmp_path, prompt_capture_boundary, defect):
+    config, captured = prompt_capture_boundary
+    wav = tmp_path / "prompt.wav"
+    if defect != "missing_file":
+        wav.write_bytes(b"" if defect == "empty_file" else b"fixture waveform bytes")
+    entry = {"path": str(wav), "text": "Twelve plus seven?",
+             "sha256": hashlib.sha256(b"fixture waveform bytes").hexdigest(), "renderer": "fixture"}
+    if defect in entry:
+        del entry[defect]
+    elif defect == "blank_renderer":
+        entry["renderer"] = " "
+    elif defect == "invalid_hash":
+        entry["sha256"] = "not-a-sha256"
+    config["prompt_wavs"] = {"arithmetic": None if defect == "entry_not_object" else entry}
+    if defect == "map_not_object":
+        config["prompt_wavs"] = []
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": "Twelve plus seven?"})
+    assert result["verdict"] == "FAIL"
+    assert result["failure"].startswith("prompt_wav")
+    assert result["capture"] == "INCONCLUSIVE"
+    assert captured == []
+
+
+@pytest.mark.parametrize("threshold", [None, .25, 0, 1])
+def test_response_vad_threshold_does_not_change_prompt_transcription(tmp_path, monkeypatch, prompt_capture_boundary, threshold):
+    config, _ = prompt_capture_boundary
+    expected = .5 if threshold is None else float(threshold)
+    if threshold is not None:
+        config["response_vad_threshold"] = threshold
+    config.update(python="fixture-python", model="fixture-model",
+                  finish_at="2099-01-01T01:00:00+00:00")
+    boundary_command = runner.command
+    monkeypatch.setattr(runner, "command", lambda argv, **kwargs:
+                        "" if argv[0] == "ffmpeg" else boundary_command(argv, **kwargs))
+    monkeypatch.setattr(runner, "verify", lambda *args, **kwargs: {"audio_seconds": 40, "video_seconds": 40})
+    monkeypatch.setattr(runner, "audio_metrics", lambda *args, **kwargs: {"fixture": True})
+    def logs(host, start, end, directory):
+        (directory / "xiaozhi-esp32-server.log").write_text("结果: Twelve plus seven\nSentenceType.FIRST")
+    monkeypatch.setattr(runner, "read_log_window", logs)
+    transcriptions = {}
+    def process(argv, log, session, timeout, env=None, deadline=None):
+        directory = Path(log).parent
+        if "transcribe" not in argv:
+            for name, second in (("recording-start", 0), ("playback-start", 2), ("playback-end", 5)):
+                (directory / f"raw.{name}.txt").write_text(f"2026-09-12T12:00:0{second}+00:00")
+            return
+        label = Path(argv[3]).stem
+        transcriptions[label] = argv
+        threshold = float(argv[argv.index("--vad-threshold") + 1]) if "--vad-threshold" in argv else .5
+        output = Path(argv[argv.index("--output") + 1])
+        runner.write_json(output, {**transcript("nineteen" if label == "response" else "Twelve plus seven"),
+                                  "vad_parameters": {"threshold": threshold}, "vad_filter": True,
+                                  "analysis": {"enabled": "--normalize" in argv}, "model": "fixture-model"})
+    monkeypatch.setattr(runner, "guarded_process", process)
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": "Twelve plus seven?",
+                                               "asr": [["twelve"], ["seven"]], "reply": [["nineteen"]]})
+    assert result["interaction"] == "PASS", result
+    response = transcriptions["response"]
+    assert float(response[response.index("--vad-threshold") + 1]) == expected
+    assert "--vad-threshold" not in transcriptions["prompt-heard"]
+    assert result["response_vad_threshold"] == expected
+    assert result["transcription_analysis"]["response"]["vad_parameters"] == {"threshold": expected}
+    assert result["transcription_analysis"]["prompt-heard"]["vad_parameters"] == {"threshold": .5}
+
+
+@pytest.mark.parametrize("threshold", [-.1, 1.1, float("nan"), float("inf"), -float("inf"),
+                                        True, False, None, ".25", [], {}])
+def test_invalid_response_vad_threshold_rejected_before_capture(tmp_path, prompt_capture_boundary, threshold):
+    config, captured = prompt_capture_boundary
+    config["response_vad_threshold"] = threshold
+    result = runner.run_case(tmp_path, config, {"id": "arithmetic", "prompt": "Twelve plus seven?"})
+    assert result["failure"] == "response_vad_threshold_must_be_finite_number_between_0_and_1"
+    assert result["capture"] == "INCONCLUSIVE"
+    assert captured == []
+
+
+@pytest.mark.parametrize("arguments, expected", [([], .5), (["--response-vad-threshold", "0.25"], .25)])
+def test_init_persists_response_vad_setting(tmp_path, monkeypatch, arguments, expected):
+    monkeypatch.setattr(sys, "argv", ["dotty_overnight.py", "init", "--session", str(tmp_path),
+                                     "--host", "fixture@fixture-host", *arguments])
+    monkeypatch.setattr(runner, "admin", lambda host, route: {"devices": ["fixture-robot"]})
+    monkeypatch.setattr(runner, "command", lambda *args, **kwargs: "fixture-speaker\n")
+    runner.main()
+    assert runner.load(tmp_path / "config.json")["response_vad_threshold"] == expected
+
+
+def test_init_requires_explicit_deployment_host(tmp_path, monkeypatch):
+    monkeypatch.delenv("DOTTY_TEST_HOST", raising=False)
+    session = tmp_path / "not-created"
+    monkeypatch.setattr(sys, "argv", ["dotty_overnight.py", "init", "--session", str(session)])
+    monkeypatch.setattr(runner, "admin", lambda *args: pytest.fail("must not contact an assumed host"))
+    with pytest.raises(SystemExit) as error:
+        runner.main()
+    assert error.value.code == 2
+    assert not session.exists()
+
+
+def test_init_accepts_explicit_host_environment(tmp_path, monkeypatch):
+    monkeypatch.setenv("DOTTY_TEST_HOST", "fixture@fixture-host")
+    monkeypatch.setattr(sys, "argv", ["dotty_overnight.py", "init", "--session", str(tmp_path)])
+    seen = []
+    def admin(host, route):
+        seen.append((host, route))
+        return {"devices": ["fixture-robot"]}
+    monkeypatch.setattr(runner, "admin", admin)
+    monkeypatch.setattr(runner, "command", lambda *args, **kwargs: "fixture-speaker\n")
+    runner.main()
+    assert seen == [("fixture@fixture-host", "devices")]
+    assert runner.load(tmp_path / "config.json")["host"] == "fixture@fixture-host"
+
+
+def test_preflight_reports_response_vad_setting(tmp_path, monkeypatch):
+    monkeypatch.setattr(runner, "snapshot", lambda host: after())
+    monkeypatch.setattr(runner, "space_ok", lambda session: True)
+    result = runner.preflight(tmp_path, {"host": "unused", "model": str(tmp_path), "response_vad_threshold": .25})
+    assert result["response_vad_threshold"] == .25
+
+
+def test_preflight_rejects_invalid_vad_before_external_checks(tmp_path, monkeypatch):
+    def no_snapshot(*args):
+        pytest.fail("invalid config must not access the live host")
+    monkeypatch.setattr(runner, "snapshot", no_snapshot)
+    with pytest.raises(ValueError, match="response_vad_threshold"):
+        runner.preflight(tmp_path, {"host": "unused", "response_vad_threshold": float("nan")})
+
+
+@pytest.mark.parametrize("command, threshold", [("init", "nan"), ("init", "inf"), ("init", "-0.1"),
+                                                ("init", "1.1"), ("run", ".25"), ("resume", ".25")])
+def test_vad_cli_cannot_silently_override_existing_config(tmp_path, monkeypatch, command, threshold):
+    session = tmp_path / "not-created"
+    monkeypatch.setattr(sys, "argv", ["dotty_overnight.py", command, "--session", str(session),
+                                      "--response-vad-threshold", threshold])
+    with pytest.raises(SystemExit) as error:
+        runner.main()
+    assert error.value.code == 2
+    assert not session.exists()
+
+
+def test_blocked_prerequisite_does_not_increment_failure_threshold(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    runner.record_attempt(checkpoint, {"id": "wake"},
+                          {"verdict": "BLOCKED", "failure": "wake_precondition"})
+    assert checkpoint["blocked"] == {"wake": "wake_precondition"}
+    assert checkpoint["counts"]["wake"]["failures"] == 0
+    assert checkpoint["consecutive_failures"] == 0
+    assert checkpoint["completed"] == []
+
+
+def test_cannot_pool_unrelated_asr_requests():
+    result = runner.evaluate({"asr": [["purple"], ["robot"]]}, transcript("yes"),
+                             "结果: purple\n结果: robot\nSentenceType.FIRST", 10, after(), "robot")
+    assert result["failure"] == "asr_mismatch"
+
+
+def test_missing_listening_state_is_not_recovery():
+    state = after()
+    del state["perception"]["robot"]["listening"]
+    result = runner.evaluate({"asr": [["name"]]}, transcript("Dotty"),
+                             "结果: name\nSentenceType.FIRST", 10, state, "robot")
+    assert result["recovery"] == "FAIL"
+
+
+def test_low_confidence_hallucination_is_not_audible_response():
+    speech = transcript("Dotty")
+    speech["segments"][0]["avg_logprob"] = -2
+    result = runner.evaluate({}, speech, "结果: name\nSentenceType.FIRST", 10, after(), "robot")
+    assert result["failure"] == "response_transcription_unavailable"
+    assert result["interaction"] == "INCONCLUSIVE"
+
+
+def test_playback_window_crosses_midnight(tmp_path):
+    for name, stamp in {
+        "recording-start": "2026-09-12T23:59:56+00:00",
+        "playback-start": "2026-09-12T23:59:59+00:00",
+        "playback-end": "2026-09-13T00:00:05+00:00",
+    }.items():
+        (tmp_path / f"raw.{name}.txt").write_text(stamp)
+    assert runner.playback_window(tmp_path, 30) == (3, 9.4)
+    with pytest.raises(ValueError, match="truncated"):
+        runner.playback_window(tmp_path, 9)
+
+
+def test_host_timestamp_preserves_date_and_offset():
+    assert runner.host_timestamp("2026-09-12T23:59:59+00:00", {"offset_seconds": 2}) == "2026-09-13T00:00:01+00:00"
+
+
+def test_interrupted_case_quarantined_before_active_cleared(tmp_path):
+    result_path = tmp_path / "cases" / "unique-attempt" / "result.json"
+    runner.write_json(result_path, {"case_id": "memory-write", "verdict": "INCONCLUSIVE"})
+    runner.write_json(tmp_path / "active.json", {"case": "unique-attempt"})
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    assert checkpoint["completed"] == []
+    assert checkpoint["quarantined"] == ["memory-write"]
+    assert runner.load(tmp_path / "active.json") == {}
+    assert runner.load(result_path)["failure"] == "interrupted_case_requires_review"
+    assert runner.restore_checkpoint(tmp_path)["quarantined"] == ["memory-write"]
+
+
+def test_unknown_interrupted_identity_blocks_replay(tmp_path):
+    runner.write_json(tmp_path / "active.json", {"case": "missing-attempt"})
+    with pytest.raises(RuntimeError, match="identity unknown"):
+        runner.restore_checkpoint(tmp_path)
+    assert runner.load(tmp_path / "active.json")
+
+
+def test_checkpointed_attempt_not_quarantined_after_clear_crash(tmp_path):
+    runner.write_json(tmp_path / "checkpoint.json", {"last_attempt": "finished-attempt"})
+    runner.write_json(tmp_path / "active.json", {"case": "finished-attempt", "case_id": "identity"})
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    assert checkpoint["quarantined"] == []
+    assert runner.load(tmp_path / "active.json") == {}
+
+
+def test_success_requires_streak_and_all_evidence(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    case = {"id": "identity"}
+    good = dict.fromkeys(("capture", "playback", "interaction", "recovery"), "PASS")
+    runner.record_attempt(checkpoint, case, good)
+    runner.record_attempt(checkpoint, case, {**good, "playback": "INCONCLUSIVE"})
+    runner.record_attempt(checkpoint, case, good)
+    runner.record_attempt(checkpoint, case, good)
+    assert checkpoint["completed"] == []
+    runner.record_attempt(checkpoint, case, good)
+    assert checkpoint["completed"] == ["identity"]
+
+
+def test_failure_threshold_quarantines_and_pauses(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    for _ in range(3):
+        runner.record_attempt(checkpoint, {"id": "identity"}, {"verdict": "FAIL"})
+    assert checkpoint["consecutive_failures"] == 3
+    assert checkpoint["quarantined"] == ["identity"]
+    assert checkpoint["completed"] == []
+
+
+def test_operator_interruption_is_not_automatically_retried(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    runner.record_attempt(checkpoint, {"id": "memory-write"}, {"exception": "InterruptedError"})
+    assert checkpoint["quarantined"] == ["memory-write"]
+
+
+def test_device_lock_prevents_two_output_sessions():
+    config = {"device": "pytest-lock-only-no-hardware"}
+    with runner.device_lock(config):
+        with pytest.raises(BlockingIOError):
+            with runner.device_lock(config):
+                pass
+
+
+def test_guarded_process_does_not_leave_child_on_stop(tmp_path, monkeypatch):
+    monkeypatch.setattr(runner, "STOP", True)
+    with pytest.raises(InterruptedError):
+        runner.guarded_process([sys.executable, "-c", "import time; time.sleep(30)"],
+                               tmp_path / "process.log", tmp_path, 60)
+
+
+def test_deadline_prevents_launch(tmp_path):
+    with pytest.raises(TimeoutError, match="before process launch"):
+        runner.guarded_process(["this-command-must-never-start"], tmp_path / "log",
+                               tmp_path, 60, deadline=0)
+    assert not (tmp_path / "log").exists()
+
+
+# --- #182: unattended operation and evaluator false alarms. AI-assisted: Claude. ---
+
+def test_reference_mic_mishearing_is_inconclusive_when_service_tts_matches():
+    logs = "结果: name\n发送音频消息: SentenceType.FIRST, My name is Dotty\nSentenceType.LAST"
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, transcript("Your name is Dadi"),
+                             logs, 2, after(), "robot")
+    assert result["failure"] == "response_transcript_disagrees_with_tts"
+    assert result["interaction"] == result["verdict"] == "INCONCLUSIVE"
+    assert result["service_tts_text"] == "My name is Dotty"
+
+
+def test_wrong_reply_still_fails_when_service_tts_also_lacks_the_answer():
+    logs = "结果: name\n发送音频消息: SentenceType.FIRST, I like trains\nSentenceType.LAST"
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, transcript("I like trains"),
+                             logs, 2, after(), "robot")
+    assert result["failure"] == "response_mismatch"
+    assert result["interaction"] == "FAIL"
+
+
+def test_extra_recognised_speech_makes_the_case_inconclusive():
+    logs = ("结果: what is your name\n识别文本: what is your name\n"
+            "发送音频消息: SentenceType.FIRST, My name is Dotty\nSentenceType.LAST\n"
+            "结果: I made a house\n识别文本: I made a house\n")
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, transcript("My name is Dotty"),
+                             logs, 2, after(), "robot")
+    assert result["extra_speech"] == ["I made a house"]
+    assert result["failure"] == "extra_speech_in_capture"
+    assert result["interaction"] == result["verdict"] == "INCONCLUSIVE"
+
+
+def test_rejected_or_empty_recognitions_are_not_extra_speech():
+    logs = ("结果: what is your name\n识别文本: what is your name\n"
+            "发送音频消息: SentenceType.FIRST, My name is Dotty\nSentenceType.LAST\n"
+            "结果: Thank you.\nASR-REJECT no_speech=0.811 > 0.60 | dropped 'Thank you.'\n结果: \n")
+    result = runner.evaluate({"asr": [["name"]], "reply": [["Dotty"]]}, transcript("My name is Dotty"),
+                             logs, 2, after(), "robot")
+    assert result["extra_speech"] == []
+    assert result["failure"] is None
+
+
+@pytest.mark.parametrize("heard,asr_ok,expected", [
+    ("repeat purple robot", True, ("PASS", "reference_mic")),
+    ("repeat purple brisket", True, ("PASS", "robot_asr")),
+    ("repeat purple brisket", False, ("INCONCLUSIVE", None)),
+    ("", False, ("INCONCLUSIVE", None)),
+])
+def test_playback_is_proven_by_reference_mic_or_by_the_robot_hearing_it(heard, asr_ok, expected):
+    assert runner.playback_verdict(heard, asr_ok, [["robot"]]) == expected
+
+
+def test_inconclusive_attempt_resets_streak_without_counting_as_failure(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    good = dict.fromkeys(("capture", "playback", "interaction", "recovery"), "PASS")
+    runner.record_attempt(checkpoint, {"id": "identity"}, good)
+    for _ in range(4):
+        runner.record_attempt(checkpoint, {"id": "identity"}, {**good, "interaction": "INCONCLUSIVE"})
+    counts = checkpoint["counts"]["identity"]
+    assert (counts["streak"], counts["failures"]) == (0, 0)
+    assert checkpoint["consecutive_failures"] == 0
+    assert checkpoint["quarantined"] == []
+
+
+def test_mic_opener_refreshes_a_stale_listening_status_before_capture(
+        tmp_path, monkeypatch, prompt_capture_boundary):
+    config, captured = prompt_capture_boundary
+    calls = []
+    snapshots = iter([
+        {**after(), "devices": ["robot"]},                                    # idle, mic closed
+        {**after(current_state="talk", listening=True, sensor_age_s=1), "devices": ["robot"]},   # too fresh
+        {**after(current_state="talk", listening=True, sensor_age_s=5), "devices": ["robot"]},   # settled
+    ])
+    monkeypatch.setattr(runner, "snapshot", lambda host: next(snapshots))
+    monkeypatch.setattr(runner, "admin", lambda host, route, body=None: calls.append((route, body)) or {"ok": True})
+    monkeypatch.setattr(runner.time, "sleep", lambda seconds: None)
+    result = runner.run_case(tmp_path, {**config, "mic_opener": "admin_say"},
+                             {"id": "identity", "prompt": "What is your name?",
+                              "require_warm_listening": True})
+    assert calls == [("say", {"device_id": "robot", "text": "Ready."})]
+    assert result["mic_opened_by"] == "admin_say"
+    assert result["warm_listening_precondition"] == "PASS"
+    assert len(captured) == 1                     # reached the capture boundary
+    assert result["failure"] == "fixture_capture_stop"
+
+
+def test_mic_opener_that_never_opens_the_mic_still_blocks(tmp_path, monkeypatch, prompt_capture_boundary):
+    config, captured = prompt_capture_boundary
+    monkeypatch.setattr(runner, "admin", lambda host, route, body=None: {"ok": True})
+    monkeypatch.setattr(runner.time, "sleep", lambda seconds: None)
+    monkeypatch.setattr(runner, "MIC_OPEN_POLLS", 3)
+    result = runner.run_case(tmp_path, {**config, "mic_opener": "admin_say"},
+                             {"id": "identity", "prompt": "What is your name?",
+                              "require_warm_listening": True})
+    assert result["verdict"] == "BLOCKED"
+    assert result["failure"] == "warm_listening_precondition"
+    assert captured == []
+
+
+def test_init_persists_mic_opener(tmp_path, monkeypatch):
+    monkeypatch.setattr(runner, "admin", lambda host, route, body=None: {"devices": ["robot"]})
+    monkeypatch.setattr(runner, "command", lambda argv, **kwargs: "fixture-speaker\n")
+    monkeypatch.setattr(sys, "argv", ["dotty_overnight.py", "init", "--session", str(tmp_path),
+                                      "--host", "user@host", "--mic-opener", "admin_say"])
+    runner.main()
+    assert json.loads((tmp_path / "config.json").read_text())["mic_opener"] == "admin_say"
+
+
+def test_misheard_prompt_is_an_asr_mismatch_not_extra_speech():
+    logs = ("结果: Repeat these words purple frispen\n识别文本: Repeat these words purple frispen\n"
+            "发送音频消息: SentenceType.FIRST, purple frispen\nSentenceType.LAST\n")
+    result = runner.evaluate({"asr": [["purple"], ["Brisbane"]], "reply": [["purple"]]},
+                             transcript("purple frispen"), logs, 2, after(), "robot")
+    assert result["extra_speech"] == []
+    assert result["failure"] == "asr_mismatch"
+    assert result["interaction"] == "FAIL"
+
+
+def test_repeatedly_inconclusive_case_is_set_aside_instead_of_retried_forever(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    murky = {**dict.fromkeys(("capture", "playback", "recovery"), "PASS"), "interaction": "INCONCLUSIVE"}
+    for _ in range(2):
+        runner.record_attempt(checkpoint, {"id": "repeat"}, murky)
+    assert checkpoint["unresolved"] == []
+    runner.record_attempt(checkpoint, {"id": "repeat"}, murky)
+    assert checkpoint["unresolved"] == ["repeat"]
+    assert checkpoint["quarantined"] == [] and checkpoint["counts"]["repeat"]["failures"] == 0
+    assert runner.eligible_cases([{"id": "repeat"}, {"id": "other"}], checkpoint) == [{"id": "other"}]
+
+
+def test_a_pass_clears_the_inconclusive_count(tmp_path):
+    checkpoint = runner.restore_checkpoint(tmp_path)
+    good = dict.fromkeys(("capture", "playback", "interaction", "recovery"), "PASS")
+    murky = {**good, "interaction": "INCONCLUSIVE"}
+    for attempt in (murky, murky, good, murky, murky):
+        runner.record_attempt(checkpoint, {"id": "repeat"}, attempt)
+    assert checkpoint["unresolved"] == []
diff --git a/tests/test_state_phrase_routing.py b/tests/test_state_phrase_routing.py
new file mode 100644
index 00000000..31bdbe73
--- /dev/null
+++ b/tests/test_state_phrase_routing.py
@@ -0,0 +1,110 @@
+"""Real ASR-to-state routing regressions; AI-assisted by OpenAI Codex (GPT-6).
+
+Container imports are isolated by the existing fixture module. Only external
+intent/STT/MCP boundaries and the executor are faked; routing remains real.
+"""
+
+import asyncio
+import json
+import types
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from tests.test_asr_name_corrections import _module
+
+
+def route(text, state="idle"):
+    conn = types.SimpleNamespace(
+        logger=MagicMock(), need_bind=False, max_output_size=0,
+        client_is_speaking=False, current_state=state, session_id="fixture",
+        websocket=types.SimpleNamespace(send=AsyncMock()),
+        executor=MagicMock(), chat=MagicMock(),
+        _dotty_toggles_synced=True,
+    )
+    commands = AsyncMock()
+    with patch.object(_module, "handle_user_intent", new=AsyncMock(return_value=False)), \
+         patch.object(_module, "send_stt_message", new=AsyncMock()), \
+         patch.object(_module, "_mcp_call_tool", new=commands):
+        asyncio.run(_module.startToChat(conn, json.dumps({"content": text})))
+    states = [call.args[2]["state"] for call in commands.await_args_list
+              if call.args[1] == "self.robot.set_state"]
+    return states, conn.executor.submit.call_args.args[1]
+
+
+def test_explicit_do_not_sleep_is_conversation_not_state_command():
+    states, prompt = route("Do not go to sleep.")
+    assert states == []
+    assert prompt == "Do not go to sleep."
+
+
+@pytest.mark.parametrize("negation", ["Do not", "Don't", "Don’t", "Never"])
+@pytest.mark.parametrize("command", ["go to sleep", "tell me a story", "keep watch"])
+def test_explicit_negated_state_commands_do_not_dispatch(negation, command):
+    states, prompt = route(f"Please {negation} {command}.")
+    assert states == []
+    assert negation in prompt
+
+
+@pytest.mark.parametrize("quote", [('"', '"'), ("'", "'"), ('“', '”'), ('‘', '’')])
+def test_quoted_story_command_is_a_mention_not_a_state_change(quote):
+    text = f"What does {quote[0]}tell me a story{quote[1]} mean?"
+    states, prompt = route(text)
+    assert states == []
+    assert prompt == text
+
+
+@pytest.mark.parametrize("text, expected", [
+    ("Goodnight Dotty.", "sleep"),
+    ("Good night, Dotty.", "sleep"),
+    ("Please go to sleep.", "sleep"),
+    ("Please keep watch.", "security"),
+    ("Security mode.", "security"),
+    ("Watch the room.", "security"),
+    ("Please tell me a story.", "story_time"),
+    ("Story time.", "story_time"),
+    ("Don't keep watch. Tell me a story.", "story_time"),
+    ("Don't keep watch, but tell me a story.", "story_time"),
+    ('The phrase "never" is interesting. Please go to sleep.', "sleep"),
+])
+def test_affirmative_state_commands_still_dispatch(text, expected):
+    states, _ = route(text)
+    assert states == [expected]
+
+
+@pytest.mark.parametrize("state", ["sleep", "security", "story_time"])
+@pytest.mark.parametrize("text", ["Wake up.", "Come back.", "Are you there?",
+                                  "Don't go to sleep, wake up."])
+def test_affirmative_wake_escape_still_dispatches_idle(state, text):
+    states, _ = route(text, state)
+    assert states == ["idle"]
+
+
+@pytest.mark.parametrize("text", [
+    'What does "wake up" mean?', "Don't wake up.", "Never come back.",
+])
+def test_quoted_or_negated_wake_is_not_an_escape_command(text):
+    states, _ = route(text, "story_time")
+    assert states == []
+
+
+@pytest.mark.parametrize("text", [
+    "Please don't ever go to sleep.",
+    "Never, please tell me a story.",
+    "Don't you go to sleep.",
+    "Do not, tell me a story.",
+    'Say "go to sleep" out loud.',
+    'Explain “security mode” to me.',
+    "What does 'don't go to sleep' mean?",
+    "What's the meaning of 'tell me a story'?",
+    "Tell me. A story is something I dislike.",
+    "Explain the story timetable.",
+])
+def test_punctuation_and_mentions_do_not_manufacture_state_commands(text):
+    states, _ = route(text)
+    assert states == []
+
+
+def test_unrelated_contraction_does_not_hide_an_affirmative_command():
+    states, _ = route("I'm ready, please tell me a story.")
+    assert states == ["story_time"]
diff --git a/tests/test_voice_camera_policy.py b/tests/test_voice_camera_policy.py
new file mode 100644
index 00000000..2e34b080
--- /dev/null
+++ b/tests/test_voice_camera_policy.py
@@ -0,0 +1,87 @@
+"""Voice-only camera privacy regressions; AI-assisted by Codex (GPT-6)."""
+import asyncio
+import json
+import types
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from tests.test_asr_name_corrections import _module
+
+
+@pytest.fixture
+def policy(tmp_path, monkeypatch):
+    path = tmp_path / "kid-mode"
+    monkeypatch.setattr(_module, "_KID_MODE_STATE_FILE", str(path))
+    monkeypatch.setenv("DOTTY_KID_MODE", "false")
+    monkeypatch.setattr(_module, "VISION_BRIDGE_URL", "http://synthetic.invalid")
+    return path
+
+
+@pytest.mark.parametrize("value, denied", [("true", True), ("1", True), ("yes", True),
+    ("false", False), ("0", False), ("no", False), (" FALSE\n", False),
+    ("", True), ("garbage", True)])
+def test_camera_policy_uses_explicit_current_state(policy, value, denied):
+    policy.write_text(value)
+    assert _module._camera_access_denied() is denied
+
+
+def test_missing_unreadable_or_invalid_policy_denies_even_with_adult_env(policy):
+    assert _module._camera_access_denied() is True
+    policy.mkdir()
+    assert _module._camera_access_denied() is True
+    policy.rmdir()
+    policy.write_bytes(b"\xff")
+    assert _module._camera_access_denied() is True
+
+
+def test_camera_policy_refreshes_without_process_restart(policy):
+    for value, denied in [("false", False), ("true", True), ("false", False)]:
+        policy.write_text(value)
+        assert _module._camera_access_denied() is denied
+
+
+def test_physical_capture_boundary_denies_before_dispatch(policy):
+    policy.write_text("true")
+    conn = types.SimpleNamespace(logger=MagicMock(), headers={"device-id": "fixture"})
+    dispatch = AsyncMock(side_effect=AssertionError("camera dispatch must not happen"))
+    with patch.object(_module, "_mcp_call_tool", dispatch):
+        with pytest.raises(PermissionError, match="Kid Mode"):
+            asyncio.run(_module._handle_vision(conn, "What do you see?"))
+    dispatch.assert_not_awaited()
+
+
+def test_voice_denial_never_becomes_successful_photo_prompt(policy):
+    policy.write_text("true")
+    conn = types.SimpleNamespace(logger=MagicMock(), need_bind=False, max_output_size=0,
+        client_is_speaking=False, current_state="idle", session_id="fixture",
+        websocket=types.SimpleNamespace(send=AsyncMock()), executor=MagicMock(),
+        chat=MagicMock(), headers={"device-id": "fixture"}, _dotty_toggles_synced=True)
+    dispatch = AsyncMock(side_effect=AssertionError("camera dispatch must not happen"))
+    with patch.object(_module, "handle_user_intent", AsyncMock(return_value=False)), \
+         patch.object(_module, "send_stt_message", AsyncMock()), \
+         patch.object(_module, "_mcp_call_tool", dispatch):
+        asyncio.run(_module.startToChat(conn, json.dumps({"content": "What do you see?"})))
+    dispatch.assert_not_awaited()
+    prompt = conn.executor.submit.call_args.args[1]
+    assert "Kid Mode" in prompt
+    assert "just used your camera" not in prompt
+    assert "photo shows" not in prompt
+
+
+def test_adult_physical_capture_preserves_result(policy, monkeypatch):
+    policy.write_text("false")
+    conn = types.SimpleNamespace(logger=MagicMock(), headers={"device-id": "fixture"})
+    response = types.SimpleNamespace(status_code=200, json=lambda: {"description": "Synthetic cube."})
+    async def run():
+        loop = asyncio.get_running_loop()
+        async def synthetic_executor(*args):
+            return response
+        dispatch = AsyncMock()
+        with patch.object(loop, "run_in_executor", synthetic_executor), \
+             patch.object(_module, "_mcp_call_tool", dispatch):
+            assert await _module._handle_vision(conn, "What do you see?") == "Synthetic cube."
+        dispatch.assert_awaited_once_with(conn, "self.camera.take_photo", {"question": "What do you see?"})
+    # requests is imported by the real function, but its client must not run.
+    monkeypatch.setitem(__import__("sys").modules, "requests", types.SimpleNamespace(get=None))
+    asyncio.run(run())
diff --git a/tests/test_whisper_no_speech_gate.py b/tests/test_whisper_no_speech_gate.py
new file mode 100644
index 00000000..76b2a89f
--- /dev/null
+++ b/tests/test_whisper_no_speech_gate.py
@@ -0,0 +1,76 @@
+"""WhisperLocal must not hand near-silence hallucinations to the LLM.
+
+AI-assisted (Claude). Observed on the physical robot 2026-10-05: 1.3 s of
+near-silence after Dotty finished speaking was transcribed as "Thank you."
+with no_speech_prob=0.81, and Dotty replied to it. Every real utterance
+captured that day scored <= 0.32.
+"""
+import asyncio
+import importlib.util
+import pathlib
+import sys
+import types
+from contextlib import contextmanager
+from unittest.mock import MagicMock
+
+import numpy as np
+
+_ROOT = pathlib.Path(__file__).parent.parent
+_STUBS = ("faster_whisper", "config", "config.logger", "core", "core.providers",
+          "core.providers.asr", "core.providers.asr.base", "core.providers.asr.dto",
+          "core.providers.asr.dto.dto")
+
+
+@contextmanager
+def _stubs():
+    missing = object()
+    previous = {name: sys.modules.get(name, missing) for name in _STUBS}
+    try:
+        for name in _STUBS:
+            sys.modules[name] = types.ModuleType(name)
+        sys.modules["faster_whisper"].WhisperModel = MagicMock()
+        sys.modules["config.logger"].setup_logging = lambda: MagicMock()
+        sys.modules["core.providers.asr.base"].ASRProviderBase = type(
+            "ASRProviderBase", (), {"__init__": lambda self: None})
+        sys.modules["core.providers.asr.dto.dto"].InterfaceType = types.SimpleNamespace(LOCAL="local")
+        yield
+    finally:
+        for name, module in previous.items():
+            if module is missing:
+                sys.modules.pop(name, None)
+            else:
+                sys.modules[name] = module
+
+
+def _load():
+    with _stubs():
+        spec = importlib.util.spec_from_file_location(
+            "whisper_local_under_test", _ROOT / "custom-providers/asr/whisper_local.py")
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+    return module
+
+
+def _transcribe(no_speech_probs, text, config=None):
+    module = _load()
+    provider = module.ASRProvider.__new__(module.ASRProvider)
+    provider.no_speech_threshold = module._no_speech_threshold(config or {})
+    segments = [types.SimpleNamespace(text=text if i == 0 else "", no_speech_prob=p, avg_logprob=-0.5)
+                for i, p in enumerate(no_speech_probs)]
+    provider._transcribe_blocking = lambda audio: (segments, types.SimpleNamespace(language_probability=1.0))
+    artifacts = types.SimpleNamespace(pcm_bytes=np.zeros(16000, dtype=np.int16).tobytes(), file_path="x.wav")
+    result, _path = asyncio.run(provider.speech_to_text([], "session", artifacts=artifacts))
+    return result
+
+
+def test_high_no_speech_transcript_is_dropped():
+    assert _transcribe([0.811], " Thank you.") == {"content": ""}
+
+
+def test_real_speech_passes_through():
+    assert _transcribe([0.32], " See you soon!") == {"content": "See you soon!"}
+
+
+def test_threshold_is_configurable_and_can_be_disabled():
+    assert _transcribe([0.811], " Thank you.", {"no_speech_threshold": 1.0}) == {"content": "Thank you."}
+    assert _transcribe([0.5], " Hello.", {"no_speech_threshold": 0.4}) == {"content": ""}