diff --git a/CHANGELOG.md b/CHANGELOG.md
index f373bd93..2566a714 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -67,6 +67,38 @@ experience may change before `1.0.0`.
 
 ### Fixed
 
+- The web header is one line of controls on the brand's centre line.
+  **Voice**, **Theme**, **Font** and **Size** each have a visible label, set
+  above the control and out of the layout, so every control is the same 32px
+  height and sits on one centre line; the voice picker matches the other
+  pickers instead of a smaller 12px style. The voice-engine badge ("System
+  voices", "Kokoro (server)") is a coloured dot and small text beside the Voice
+  label, yellow when something other than the host's Kokoro is speaking; it
+  never had a style, so it rendered as large bold text in the middle of the
+  header. At a 1024px tablet width with the semantic chip showing, the controls
+  wrap instead of running 75px past the window.
+- CSS and JavaScript are revalidated before a browser reuses them
+  (`Cache-Control: no-cache`, answered with a 304 when unchanged), like the page
+  itself. They were sent with no Cache-Control, so after an update a browser
+  could pair the new page with a days-old stylesheet or script.
+- `studyloop doctor` no longer gives advice that is wrong or leads nowhere:
+  - `project_aliases` is no longer called inert. Session search reads it
+    (`PROJECT_ALIASES.md`), and deleting it as the row advised would have cut
+    `--project` searches off from every aliased path.
+  - Grok Build's definition is checked against the repo-root `AGENTS.md` it
+    shares with Codex, instead of "No manifest entry for grok".
+  - The xTiles row says whether the wind-down skill is installed and which
+    harnesses register an `xtiles` MCP server; the offer can only appear in a
+    session connected to one.
+  - A stale `export_freshness` row lists every harness's own age, and says so
+    when kiro-cli's session store (`~/.kiro/sessions/cli/`) has moved on while
+    Kiro exports have not: kiro-cli 2.x keeps sessions there and the exporter
+    does not read it yet (#49).
+  - The Kokoro model-files row appears only for `tts.backend: kokoro`, the one
+    backend that reads them, and says they download on first use.
+  - "Obsidian export disabled" says it means the session-memory export
+    (`obsidian.export_enabled`), which is independent of `second_brain`, and
+    how to turn it on.
 - Web (ACP) Kiro sessions run StudyLoop's own `studyloop` agent. They started
   `kiro-cli acp` with no `--agent`, so each ran under whatever the learner's
   default Kiro agent was: Kiro's built-in (its own system prompt, the learner's
diff --git a/packages/studyloop/src/studyloop/doctor/agents.py b/packages/studyloop/src/studyloop/doctor/agents.py
index 92886d00..d0d243fd 100644
--- a/packages/studyloop/src/studyloop/doctor/agents.py
+++ b/packages/studyloop/src/studyloop/doctor/agents.py
@@ -392,8 +392,21 @@ def check_agent_definitions() -> list[CheckResult]:
     results: list[CheckResult] = []
     manifest_agents = manifest.get("agents", {})
 
+    from studyloop.installers import _TOOL_LINKS
+
     for tool in tools:
         tool_keys = [k for k in manifest_agents if k.startswith(f"{tool}/")]
+        if not tool_keys:
+            # A harness with no definition of its own is checked against the
+            # manifest entries of the files its installer links. Grok Build reads
+            # the repo-root AGENTS.md that ``codex/AGENTS.md`` tracks; looking only
+            # for a ``grok/`` key reported "No manifest entry" and left the file it
+            # actually reads unchecked.
+            tool_keys = [
+                key
+                for spec in _TOOL_LINKS.get(tool, ())
+                if (key := spec.source.removeprefix("agents/")) in manifest_agents
+            ]
         if not tool_keys:
             results.append(
                 CheckResult(
@@ -411,6 +424,7 @@ def check_agent_definitions() -> list[CheckResult]:
             is_primary = Path(key).name == primary_name
             check_name = f"agent_{tool}" if is_primary else f"agent_{tool}_{Path(key).stem}"
             label = tool if is_primary else f"{tool} {Path(key).stem}"
+            shared = "" if key.startswith(f"{tool}/") else f" (shares {key})"
 
             if not install_path.exists():
                 results.append(
@@ -418,7 +432,7 @@ def check_agent_definitions() -> list[CheckResult]:
                         "agents",
                         check_name,
                         "warn",
-                        f"{tool} detected but agent definition not installed",
+                        f"{tool} detected but agent definition not installed{shared}",
                         "studyloop upgrade --component agents",
                         fix_auto=True,
                     )
@@ -433,7 +447,7 @@ def check_agent_definitions() -> list[CheckResult]:
                         "agents",
                         check_name,
                         "pass",
-                        f"{label} agent definition current",
+                        f"{label} agent definition current{shared}",
                         "",
                         False,
                     )
@@ -447,6 +461,7 @@ def check_agent_definitions() -> list[CheckResult]:
                         (
                             f"{label} agent definition outdated"
                             f" (local={local_hash[:8]}... expected={expected_hash[:8]}...)"
+                            f"{shared}"
                         ),
                         "studyloop upgrade --component agents",
                         fix_auto=True,
diff --git a/packages/studyloop/src/studyloop/doctor/config.py b/packages/studyloop/src/studyloop/doctor/config.py
index bfb986fd..54842009 100644
--- a/packages/studyloop/src/studyloop/doctor/config.py
+++ b/packages/studyloop/src/studyloop/doctor/config.py
@@ -176,38 +176,43 @@ def check_pandoc() -> list[CheckResult]:
     ]
 
 
+def _obsidian_export_disabled(vault: object, memory_dir: str) -> list[CheckResult]:
+    """The one "off" row for both ways export can be off.
+
+    "Obsidian export disabled" alone named no reason and no next step, and a
+    learner on ``second_brain.provider: xtiles`` read it as "off because Obsidian
+    is not my second brain". The two settings are independent: this export writes
+    session-memory notes; ``second_brain`` only chooses where study notes go.
+    """
+    target = f"{Path(str(vault)).expanduser()}/{memory_dir}" if str(vault) else memory_dir
+    return [
+        CheckResult(
+            "config",
+            "obsidian_export",
+            "info",
+            "Obsidian session-memory export disabled: obsidian.export_enabled is not true. "
+            "It is independent of second_brain, which only chooses where study notes go.",
+            f"To write session notes into {target}, set export_enabled: true under the "
+            "obsidian: section of config.yaml",
+            False,
+        )
+    ]
+
+
 def check_obsidian_export() -> list[CheckResult]:
     """Check Obsidian export configuration and vault writability.
 
     If export is enabled, verify that the resolved vault_path/memory_dir
     is present (or at least that the vault exists).  If export is disabled,
-    return an informational result.
+    return an informational result that says how to turn it on.
     """
     settings = _load_settings()
     obsidian = getattr(settings, "obsidian", None)
     if obsidian is None:
-        return [
-            CheckResult(
-                "config",
-                "obsidian_export",
-                "info",
-                "Obsidian export disabled",
-                "",
-                False,
-            )
-        ]
+        return _obsidian_export_disabled(getattr(settings, "obsidian_base", ""), "AgentMemory")
 
     if not obsidian.export_enabled:
-        return [
-            CheckResult(
-                "config",
-                "obsidian_export",
-                "info",
-                "Obsidian export disabled",
-                "",
-                False,
-            )
-        ]
+        return _obsidian_export_disabled(obsidian.vault_path, obsidian.memory_dir)
 
     # Export is enabled — verify vault_path / memory_dir is accessible.
     vault_path = Path(obsidian.vault_path).expanduser()
@@ -307,13 +312,31 @@ def check_second_brain() -> list[CheckResult]:
         return []
 
     if config.provider == "xtiles":
+        # "prompts and an opt-in assistant skill" read as "the skill still needs
+        # installing". It is installed for every harness by `studyloop install
+        # agents`; the opt-in is the learner's yes at wind-down. What decides
+        # whether the offer can ever appear is an MCP server named `xtiles` in
+        # the session, so the row says where one is registered.
+        from studyloop import installers
+
+        skill = (
+            "The wind-down skill is installed"
+            if installers.XTILES_SKILL_HUB.exists()
+            else "The wind-down skill is not installed (studyloop install agents installs it)"
+        )
+        servers = installers.xtiles_mcp_harnesses()
+        where = (
+            f"an xtiles MCP server is registered in: {', '.join(servers)}"
+            if servers
+            else "no harness here registers an xtiles MCP server, so the offer cannot appear yet"
+        )
         return [
             CheckResult(
                 "config",
                 "second_brain_provider",
                 "info",
-                "Second brain: xTiles (no programmatic backend; prompts and an "
-                "opt-in assistant skill)",
+                f"Second brain: xTiles (no programmatic backend). {skill}; it offers to "
+                f"write only in a session with an xtiles MCP server connected, and {where}.",
                 "See docs/second-brain.md for the xTiles setup and the three prompts.",
                 False,
             )
diff --git a/packages/studyloop/src/studyloop/doctor/exporter.py b/packages/studyloop/src/studyloop/doctor/exporter.py
index 7adfc0a0..66e8dfab 100644
--- a/packages/studyloop/src/studyloop/doctor/exporter.py
+++ b/packages/studyloop/src/studyloop/doctor/exporter.py
@@ -192,7 +192,11 @@ def newest_message_at(db_path: Path) -> datetime | None:
         conn.close()
     if not row or not row[0]:
         return None
-    text = str(row[0]).replace("Z", "+00:00")
+    return _parse_stamp(row[0])
+
+
+def _parse_stamp(raw: object) -> datetime | None:
+    text = str(raw).replace("Z", "+00:00")
     try:
         stamp = datetime.fromisoformat(text)
     except ValueError:
@@ -200,12 +204,59 @@ def newest_message_at(db_path: Path) -> datetime | None:
     return stamp if stamp.tzinfo else stamp.replace(tzinfo=UTC)
 
 
+#: Where kiro-cli 2.x keeps its sessions: one ``<uuid>.jsonl`` plus ``<uuid>.json``
+#: per session. The Kiro exporter still reads only data.sqlite3's conversation
+#: tables, which kiro-cli stopped updating on 2026-09-05 on the machine that
+#: reported the gap (StudyLoop #49). Until the exporter reads this store, the
+#: directory changing after the newest ``kiro_cli`` export means Kiro sessions are
+#: missing from the database. Retire this probe when #49 lands.
+KIRO_SESSIONS_DIR = Path.home() / ".kiro" / "sessions" / "cli"
+
+
+def newest_message_by_source(db_path: Path) -> dict[str, datetime]:
+    """Newest exported message per ``sessions.source``; ``{}`` when unreadable."""
+    try:
+        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    except sqlite3.Error:
+        return {}
+    try:
+        rows = conn.execute(
+            "SELECT s.source, MAX(m.timestamp) FROM messages m "
+            "JOIN sessions s ON s.id = m.session_id GROUP BY s.source"
+        ).fetchall()
+    except sqlite3.Error:
+        return {}
+    finally:
+        conn.close()
+    newest: dict[str, datetime] = {}
+    for source, raw in rows:
+        stamp = _parse_stamp(raw) if raw else None
+        if source and stamp:
+            newest[str(source)] = stamp
+    return newest
+
+
+def _age(hours: float) -> str:
+    if hours < 1:
+        return "under 1 h"
+    return f"{hours:.0f} h" if hours < 48 else f"{hours / 24:.0f} d"
+
+
 def check_export_freshness(
     db_path: Path | None = None,
     *,
     now: datetime | None = None,
     max_age_hours: float = EXPORT_FRESHNESS_HOURS,
+    kiro_sessions_dir: Path | None = None,
 ) -> CheckResult:
+    """How long ago each harness last had a message exported.
+
+    The newest message across every harness hid a 22-day Kiro gap behind a 48 h
+    Codex age (reported 2026-09-27), so a warning lists every harness's own age.
+    Kiro gets one more probe: kiro-cli's session store changing well after the
+    newest ``kiro_cli`` export means sessions the exporter cannot read (#49). That
+    warns even when another harness is fresh, because the fresh one hides it.
+    """
     db_path = db_path or _db_path()
     newest = newest_message_at(db_path) if db_path.exists() else None
     if newest is None:
@@ -217,15 +268,52 @@ def check_export_freshness(
             fix_hint="studyloop doctor --fix  (installs the export hooks), then close one session",
             fix_auto=True,
         )
-    age_hours = ((now or datetime.now(UTC)) - newest).total_seconds() / 3600
+    now = now or datetime.now(UTC)
+    by_source = newest_message_by_source(db_path)
+    listing = ", ".join(
+        f"{source} {_age((now - stamp).total_seconds() / 3600)}"
+        for source, stamp in sorted(by_source.items(), key=lambda item: item[1], reverse=True)
+    )
+
+    store = kiro_sessions_dir or KIRO_SESSIONS_DIR
+    kiro_newest = by_source.get("kiro_cli")
+    try:
+        store_changed = datetime.fromtimestamp(store.stat().st_mtime, tz=UTC)
+    except OSError:
+        store_changed = None
+    if (
+        kiro_newest is not None
+        and store_changed is not None
+        and (store_changed - kiro_newest).total_seconds() / 3600 > max_age_hours
+    ):
+        kiro_age = _age((now - kiro_newest).total_seconds() / 3600)
+        changed_age = _age((now - store_changed).total_seconds() / 3600)
+        return CheckResult(
+            category="harness",
+            name="export_freshness",
+            status="warn",
+            message=(
+                f"kiro_cli's newest export is {kiro_age} old, but kiro-cli wrote to {store} "
+                f"{changed_age} ago: kiro-cli keeps its sessions there now and the exporter "
+                f"does not read that store yet, so newer Kiro sessions are not in the "
+                f"database. By harness: {listing}"
+            ),
+            fix_hint="Nothing to repair locally; the exporter has to learn this store "
+            "(StudyLoop #49). The session files stay on disk for a later backfill.",
+            fix_auto=False,
+        )
+
+    age_hours = (now - newest).total_seconds() / 3600
     if age_hours > max_age_hours:
+        by_harness = f"; by harness: {listing}" if listing else ""
         return CheckResult(
             category="harness",
             name="export_freshness",
             status="warn",
             message=(
-                f"newest exported message is {age_hours:.0f} h old (limit {max_age_hours:.0f} h); "
-                f"if you have used a harness since, read {installers.EXPORT_HOOK_LOG}"
+                f"newest exported message is {age_hours:.0f} h old (limit {max_age_hours:.0f} h)"
+                f"{by_harness}; if you have used a harness since, read "
+                f"{installers.EXPORT_HOOK_LOG}"
             ),
             fix_hint="",
             fix_auto=False,
@@ -242,10 +330,12 @@ def check_export_freshness(
 
 __all__ = [
     "EXPORT_FRESHNESS_HOURS",
+    "KIRO_SESSIONS_DIR",
     "check_export_freshness",
     "check_exporter_schema",
     "database_user_version",
     "exporter_schema_version",
     "newest_message_at",
+    "newest_message_by_source",
     "pinned_exporter_path",
 ]
diff --git a/packages/studyloop/src/studyloop/doctor/voice.py b/packages/studyloop/src/studyloop/doctor/voice.py
index 08e6ef1c..3c38ba2b 100644
--- a/packages/studyloop/src/studyloop/doctor/voice.py
+++ b/packages/studyloop/src/studyloop/doctor/voice.py
@@ -67,28 +67,35 @@ def check_voice_readiness() -> list[CheckResult]:
         )
     )
 
-    if _KOKORO_MODEL.exists() and _KOKORO_VOICES.exists():
-        results.append(
-            CheckResult(
-                "voice",
-                "kokoro_models",
-                "pass",
-                "Kokoro model and voices are available",
-                "",
-                False,
+    # Only study-speak's local ``kokoro`` backend reads these files, and it
+    # downloads them itself on first use (agent_session_tools.speak). For any
+    # other backend the row asked a learner to pre-download ~354 MB that nothing
+    # on their machine would ever read, so it is not reported at all.
+    if backend == "kokoro":
+        if _KOKORO_MODEL.exists() and _KOKORO_VOICES.exists():
+            results.append(
+                CheckResult(
+                    "voice",
+                    "kokoro_models",
+                    "pass",
+                    "Kokoro model and voices are available",
+                    "",
+                    False,
+                )
             )
-        )
-    else:
-        results.append(
-            CheckResult(
-                "voice",
-                "kokoro_models",
-                "info",
-                "Kokoro model files are not pre-warmed",
-                "See docs/voice-output.md for the model download command",
-                False,
+        else:
+            results.append(
+                CheckResult(
+                    "voice",
+                    "kokoro_models",
+                    "info",
+                    "Kokoro model files (about 354 MB) are not downloaded yet; "
+                    "study-speak fetches them on first use",
+                    "Nothing to do. To fetch them now instead of on first use, see "
+                    "docs/voice-output.md",
+                    False,
+                )
             )
-        )
 
     afplay = shutil.which("afplay")
     results.append(
diff --git a/packages/studyloop/src/studyloop/installers.py b/packages/studyloop/src/studyloop/installers.py
index 09566bad..33996c2c 100644
--- a/packages/studyloop/src/studyloop/installers.py
+++ b/packages/studyloop/src/studyloop/installers.py
@@ -991,6 +991,34 @@ def unregister_mcp_servers(tools: list[str]) -> dict[str, int]:
     return changed
 
 
+def xtiles_mcp_harnesses() -> list[str]:
+    """Harnesses whose MCP config registers a server named ``xtiles``, sorted.
+
+    Read-only, for the doctor's xTiles row. The wind-down skill offers only in a
+    session where an ``xtiles`` MCP server is connected, so where one is
+    registered decides where the offer can ever appear. Reads the same files
+    :func:`_mcp_config_path` names; Grok Build is not read (its registration goes
+    through its own CLI). A missing or unreadable config counts as "not
+    registered there", never as an error.
+    """
+    import json
+    import tomllib
+
+    sections = {"claude": "mcpServers", "codex": "mcp_servers", "kiro": "mcpServers"}
+    sections["opencode"] = "mcp"
+    found: list[str] = []
+    for tool, section in sections.items():
+        try:
+            text = _mcp_config_path(tool).read_text(encoding="utf-8")
+            data = tomllib.loads(text) if tool == "codex" else json.loads(text)
+        except (OSError, ValueError):
+            continue
+        servers = data.get(section) if isinstance(data, dict) else None
+        if isinstance(servers, dict) and "xtiles" in servers:
+            found.append(tool)
+    return sorted(found)
+
+
 def mcp_registration_status(tools: list[str] | None = None) -> dict[str, bool]:
     """Report registration state without modifying any harness configuration."""
     import json
diff --git a/packages/studyloop/src/studyloop/settings.py b/packages/studyloop/src/studyloop/settings.py
index 19a38bcb..13127ff5 100644
--- a/packages/studyloop/src/studyloop/settings.py
+++ b/packages/studyloop/src/studyloop/settings.py
@@ -611,6 +611,12 @@ def replace_config(_current: dict[str, Any]) -> dict[str, Any]:
         "semantic_search",
         "excluded_dirs",
         "endpoints",  # legacy sync format, agent_session_tools.get_endpoints()
+        # agent_session_tools.query_utils.build_project_filter: the explicit
+        # alias groups that let session search find one project's history
+        # under old paths, usernames and worktrees (PROJECT_ALIASES.md). Read
+        # with load_config().get(), not through DEFAULT_CONFIG, so the
+        # unknown-key check called it inert and told learners to delete it.
+        "project_aliases",
     }
 )
 
diff --git a/packages/studyloop/src/studyloop/web/app.py b/packages/studyloop/src/studyloop/web/app.py
index 81b5949b..20835512 100644
--- a/packages/studyloop/src/studyloop/web/app.py
+++ b/packages/studyloop/src/studyloop/web/app.py
@@ -8,7 +8,7 @@
 
 from contextlib import asynccontextmanager
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from fastapi import FastAPI, Request
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
@@ -22,6 +22,23 @@
 STATIC_DIR = Path(__file__).parent / "static"
 
 
+class RevalidatedStaticFiles(StaticFiles):
+    """Static files the browser must revalidate before reusing.
+
+    ``/`` is served ``no-store``, but without a Cache-Control of their own the
+    CSS and JS it loads were subject to heuristic freshness -- commonly a tenth
+    of the file's age -- so a stylesheet unchanged for weeks was reused for days
+    without asking. After an update the learner got the new page beside the old
+    CSS and JS. ``no-cache`` keeps the copy and asks first; an unchanged file
+    costs a 304 against the ETag Starlette already sends.
+    """
+
+    def file_response(self, *args: Any, **kwargs: Any) -> Response:
+        response = super().file_response(*args, **kwargs)
+        response.headers["Cache-Control"] = "no-cache"
+        return response
+
+
 @asynccontextmanager
 async def _lifespan(app: FastAPI) -> AsyncIterator[None]:
     """Prepare the database, then run the session-slot reaper for the app's life.
@@ -353,7 +370,7 @@ async def session_page() -> RedirectResponse:
         return RedirectResponse(url="/#study-session")
 
     # Mount static files LAST (catch-all)
-    app.mount("/", StaticFiles(directory=str(STATIC_DIR)), name="static")
+    app.mount("/", RevalidatedStaticFiles(directory=str(STATIC_DIR)), name="static")
 
     # Security headers: wraps the FINISHED app object rather than being
     # registered via app.add_middleware(). Starlette always puts its own
diff --git a/packages/studyloop/src/studyloop/web/static/index.html b/packages/studyloop/src/studyloop/web/static/index.html
index 102a7381..38fdf36d 100644
--- a/packages/studyloop/src/studyloop/web/static/index.html
+++ b/packages/studyloop/src/studyloop/web/static/index.html
@@ -134,17 +134,25 @@
         <span class="tts-progress-label" x-text="$store.settings.ttsDownloadPct + '%'"></span>
       </div>
 
-      <select id="voice-select" class="voice-select" :class="{ hidden: !$store.settings.voiceOn }"
-              @change="$store.settings.onVoiceChange($event.target.value)" title="Choose voice"></select>
-      <!-- Which engine is ACTUALLY speaking. Shown whenever voice is on, not
-           only when something is wrong: a badge that appears only on failure
-           teaches nobody what "working" looks like, and the degraded state is
-           the one a learner most needs to be able to notice. -->
-      <span id="tts-engine-badge"
-            x-show="$store.settings.voiceOn"
-            :class="$store.settings.ttsEngineClass"
-            :title="$store.settings.ttsEngineTitle"
-            x-text="$store.settings.ttsEngineLabel"></span>
+      <!-- Voice picker, labelled like Font and Size below. The engine badge sits
+           in the label row, so it reads as a note on the picker rather than as a
+           heading (reported 2026-09-27: unstyled, it rendered as large bold text).
+           The badge says which engine is ACTUALLY speaking. Shown whenever voice
+           is on, not only when something is wrong: a badge that appears only on
+           failure teaches nobody what "working" looks like, and the degraded
+           state is the one a learner most needs to be able to notice. -->
+      <div class="header-field voice-field" x-show="$store.settings.voiceOn" x-cloak>
+        <span class="header-field-row">
+          <label class="header-field-label text-muted" for="voice-select">Voice</label>
+          <span id="tts-engine-badge"
+                x-show="$store.settings.voiceOn"
+                :class="$store.settings.ttsEngineClass"
+                :title="$store.settings.ttsEngineTitle"
+                x-text="$store.settings.ttsEngineLabel"></span>
+        </span>
+        <select id="voice-select" class="voice-select" :class="{ hidden: !$store.settings.voiceOn }"
+                @change="$store.settings.onVoiceChange($event.target.value)" title="Choose voice"></select>
+      </div>
       <!-- Encoder-warm chip (lane A4). Shown only while the semantic arm is
            loading, failed or off — the states a learner can act on; a
            permanently visible "ready" badge would just be noise. No percentage:
@@ -158,22 +166,25 @@
               @click="$store.settings.toggleTheme()" title="Toggle light/dark theme">
         <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="5"/><line x1="12" y1="1" x2="12" y2="3"/><line x1="12" y1="21" x2="12" y2="23"/><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"/><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"/><line x1="1" y1="12" x2="3" y2="12"/><line x1="21" y1="12" x2="23" y2="12"/><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"/><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"/></svg>
       </button>
-      <select class="palette-select" title="Theme palette"
-              :value="$store.settings.palette"
-              @change="$store.settings.setPalette($event.target.value)">
-        <option value="tokyo-night">Tokyo Night</option>
-        <option value="dracula">Dracula</option>
-        <option value="catppuccin-mocha">Catppuccin Mocha</option>
-        <option value="catppuccin-latte">Catppuccin Latte</option>
-        <option value="nord">Nord</option>
-        <option value="gruvbox-dark">Gruvbox Dark</option>
-        <option value="gruvbox-light">Gruvbox Light</option>
-        <option value="solarized-dark">Solarized Dark</option>
-        <option value="solarized-light">Solarized Light</option>
-        <option value="one-dark">One Dark</option>
-        <option value="rose-pine">Rosé Pine</option>
-        <option value="everforest">Everforest</option>
-      </select>
+      <label class="header-field">
+        <span class="header-field-label text-muted">Theme</span>
+        <select class="palette-select" title="Theme palette"
+                :value="$store.settings.palette"
+                @change="$store.settings.setPalette($event.target.value)">
+          <option value="tokyo-night">Tokyo Night</option>
+          <option value="dracula">Dracula</option>
+          <option value="catppuccin-mocha">Catppuccin Mocha</option>
+          <option value="catppuccin-latte">Catppuccin Latte</option>
+          <option value="nord">Nord</option>
+          <option value="gruvbox-dark">Gruvbox Dark</option>
+          <option value="gruvbox-light">Gruvbox Light</option>
+          <option value="solarized-dark">Solarized Dark</option>
+          <option value="solarized-light">Solarized Light</option>
+          <option value="one-dark">One Dark</option>
+          <option value="rose-pine">Rosé Pine</option>
+          <option value="everforest">Everforest</option>
+        </select>
+      </label>
       <!-- Reading font + font size, both with a VISIBLE label.  The user asked
            for "standard fonts other than just OpenDyslexic" when five already
            sat in this dropdown: they could not tell what the unlabelled control
diff --git a/packages/studyloop/src/studyloop/web/static/style.css b/packages/studyloop/src/studyloop/web/static/style.css
index 377f2eee..9cb3fbfc 100644
--- a/packages/studyloop/src/studyloop/web/static/style.css
+++ b/packages/studyloop/src/studyloop/web/static/style.css
@@ -136,7 +136,10 @@ header {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  padding: 16px 24px;
+  gap: 16px;
+  /* 20px, not 16px: the field labels sit in this top padding, out of the
+     layout (see .header-field), so the controls can share one centre line. */
+  padding: 20px 24px;
   border-bottom: 1px solid var(--border);
   flex-shrink: 0;
 }
@@ -145,6 +148,7 @@ header {
   display: inline-flex;
   align-items: center;
   gap: 10px;
+  flex-shrink: 0;
   text-decoration: none;
   color: inherit;
   border-radius: 6px;
@@ -176,7 +180,35 @@ header {
 
 .header-controls {
   display: flex;
-  gap: 8px;
+  /* Wrap rather than overflow. At a 1024px tablet width with every optional
+     item showing (voice field, semantic chip) the row is wider than the window;
+     it used to run past the right edge and under the brand. A wrapped row keeps
+     24px above it for its own labels. */
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  /* Every item is one 32px control now that labels are out of flow, so centre
+     is the brand's centre line for all of them. */
+  align-items: center;
+  column-gap: 8px;
+  row-gap: 24px;
+  min-width: 0;
+}
+
+/* One height for every header control. The buttons were 30.5px, the voice
+   picker 26px and the other pickers 32px, so no alignment could line up both
+   their tops and their bottoms. */
+.header-controls .toggle-btn,
+.header-controls select {
+  box-sizing: border-box;
+  height: 32px;
+}
+
+.header-controls .toggle-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding-top: 0;
+  padding-bottom: 0;
 }
 
 .toggle-btn {
@@ -197,11 +229,14 @@ header {
 .voice-select {
   background: var(--bg-card);
   border: 1px solid var(--border);
-  border-radius: 8px;
-  color: var(--text-dim);
-  font-size: 12px;
-  padding: 4px 6px;
-  max-width: 140px;
+  /* Same shape and type as .palette-select (theme, font, size): it was a
+     smaller 12px, dimmer picker, so it read as a different kind of control. */
+  border-radius: 6px;
+  color: var(--text);
+  font: inherit;
+  font-size: 0.85rem;
+  padding: 4px 8px;
+  max-width: 150px;
   cursor: pointer;
 }
 /* Alpine toggles .hidden on this select when voice output is off; without
@@ -2758,10 +2793,9 @@ body[data-palette="everforest"] {
  * class names after the work was partitioned, so no agent owned them. They
  * rendered acceptably on inherited styles, which is luck rather than design. */
 .header-field {
+  position: relative;
   display: inline-flex;
   flex-direction: column;
-  gap: 2px;
-  align-items: flex-start;
 }
 
 .header-field-label {
@@ -2771,6 +2805,69 @@ body[data-palette="everforest"] {
   text-transform: uppercase;
 }
 
+/* A field's label sits ABOVE its control but OUTSIDE the layout. While labels
+ * took part in layout, a labelled field was taller than the buttons beside it,
+ * so the row could be aligned on its top, its bottom or its middle and was
+ * wrong for one kind of item every time (reported 2026-09-28: "still not
+ * neat/central/aligned"). Out of flow, every item in the row is one 32px
+ * control, and .header-controls' align-items:center puts them all on the
+ * brand's centre line. The labels live in the header's top padding, which is
+ * why that padding is 20px rather than 16px. */
+.header-field > .header-field-label,
+.header-field > .header-field-row {
+  position: absolute;
+  left: 0;
+  bottom: calc(100% + 3px);
+  white-space: nowrap;
+}
+
+/* The voice field's label row: "VOICE" and the engine badge on one line. */
+.header-field-row {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+}
+
+/* Voice-engine badge (#tts-engine-badge). It had no rule at all from the commit
+ * that added it (de7e870b), so the span inherited the header's text styles and
+ * read as a large bold heading beside the FONT and SIZE labels (reported
+ * 2026-09-27). A coloured dot and small text, not a pill: a pill is taller than
+ * a label, which put VOICE 3px below THEME, FONT and SIZE, and it was the
+ * loudest thing in a row of quiet labels. "degraded" keeps the warn colour on
+ * purpose: a silent downgrade looks exactly like working software, which is the
+ * reason the badge exists. */
+.tts-engine-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  color: var(--text-muted);
+  font-size: 0.64rem;
+  font-weight: 600;
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.tts-engine-badge::before {
+  content: "";
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: currentColor;
+  flex-shrink: 0;
+}
+
+.tts-engine-badge.pending {
+  font-style: italic;
+}
+
+.tts-engine-badge.ok {
+  color: var(--green);
+}
+
+.tts-engine-badge.degraded {
+  color: var(--yellow);
+}
+
 /* One line of orientation above the Mastery graph. The panel's subtitle
  * describes its controls; this describes the picture, which is what a reader
  * actually needs before a node-link diagram means anything. */
diff --git a/packages/studyloop/tests/test_doctor_agents.py b/packages/studyloop/tests/test_doctor_agents.py
index 4c964af5..ecc12049 100644
--- a/packages/studyloop/tests/test_doctor_agents.py
+++ b/packages/studyloop/tests/test_doctor_agents.py
@@ -309,3 +309,44 @@ def test_checks_every_manifest_key_for_a_tool_not_just_the_first(self, tmp_path:
         assert "study-plan-architect" in secondary[0].message or "study-plan-architect" in (
             secondary[0].name
         )
+
+
+class TestSharedDefinitionIsCheckedAgainstItsSource:
+    """Grok Build has no definition of its own: it reads the repo-root AGENTS.md
+    that the ``codex/AGENTS.md`` manifest entry tracks (installers._TOOL_LINKS).
+    The doctor looked for a ``grok/`` key, found none and said "No manifest
+    entry for grok" -- a row about a file that cannot exist, while the file
+    Grok actually reads went unchecked (reported 2026-09-27)."""
+
+    @staticmethod
+    def _manifest(body: bytes) -> dict:
+        import hashlib
+
+        digest = hashlib.sha256(body).hexdigest()[:16]
+        return {"version": 1, "agents": {"codex/AGENTS.md": {"hash": digest, "updated": "x"}}}
+
+    @staticmethod
+    def _rows(tmp_path: Path, installed: bytes, manifest: dict) -> dict:
+        from studyloop.doctor.agents import check_agent_definitions
+
+        agents_md = tmp_path / "AGENTS.md"
+        agents_md.write_bytes(installed)
+        with (
+            patch("studyloop.doctor.agents._detect_ai_tools", return_value=["grok"]),
+            patch("studyloop.doctor.agents._get_agent_install_path", return_value=agents_md),
+            patch(
+                "studyloop.doctor.agents._fetch_manifest_with_reason",
+                return_value=(manifest, ""),
+            ),
+        ):
+            return {row.name: row for row in check_agent_definitions()}
+
+    def test_a_current_shared_file_passes_and_names_its_source(self, tmp_path: Path):
+        rows = self._rows(tmp_path, b"persona", self._manifest(b"persona"))
+        assert rows["agent_grok"].status == "pass"
+        assert "No manifest entry" not in rows["agent_grok"].message
+        assert "codex/AGENTS.md" in rows["agent_grok"].message
+
+    def test_a_stale_shared_file_warns(self, tmp_path: Path):
+        rows = self._rows(tmp_path, b"older persona", self._manifest(b"persona"))
+        assert rows["agent_grok"].status == "warn"
diff --git a/packages/studyloop/tests/test_doctor_config.py b/packages/studyloop/tests/test_doctor_config.py
index e88e870b..c33a80e0 100644
--- a/packages/studyloop/tests/test_doctor_config.py
+++ b/packages/studyloop/tests/test_doctor_config.py
@@ -332,3 +332,27 @@ def test_returns_warn_when_memory_dir_is_not_writable(self, tmp_path: Path):
 # owned by a different remediation lane (m5); the ttyd-retirement lane (m1)
 # that needs this check for the orphaned ttyd_port key put it in a module it
 # owns instead.
+
+
+class TestObsidianExportSaysWhyItIsOff:
+    """ "Obsidian export disabled" named no reason and no next step. The export in
+    question is the session-memory export (``obsidian.export_enabled``), which is
+    independent of ``second_brain``: a learner on ``provider: xtiles`` read the row
+    as "off because Obsidian is not my second brain" (reported 2026-09-27)."""
+
+    def test_the_row_names_the_switch_and_its_independence(self, tmp_path: Path):
+        from studyloop.doctor.config import check_obsidian_export
+
+        vault = str(tmp_path / "vault")
+        obs_cfg = _make_obsidian_config(export_enabled=False, vault_path=vault)
+        with patch(
+            "studyloop.doctor.config._load_settings",
+            return_value=_make_settings(obsidian_base=vault, obsidian=obs_cfg),
+        ):
+            (row,) = check_obsidian_export()
+
+        assert row.status == "info"
+        assert "disabled" in row.message.lower()
+        assert "second_brain" in row.message
+        assert "export_enabled: true" in row.fix_hint
+        assert "AgentMemory" in row.fix_hint
diff --git a/packages/studyloop/tests/test_doctor_exporter.py b/packages/studyloop/tests/test_doctor_exporter.py
index 420f161f..f5d570db 100644
--- a/packages/studyloop/tests/test_doctor_exporter.py
+++ b/packages/studyloop/tests/test_doctor_exporter.py
@@ -296,3 +296,71 @@ def test_zulu_timestamps_parse(self, tmp_path: Path) -> None:
     def test_an_empty_database_warns(self, tmp_path: Path) -> None:
         db = _db(tmp_path / "empty.db", 48, None)
         assert exporter.check_export_freshness(db).status == "warn"
+
+
+def _db_by_source(path: Path, newest: dict[str, datetime]) -> Path:
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE sessions(id TEXT, source TEXT)")
+    conn.execute("CREATE TABLE messages(id TEXT, session_id TEXT, timestamp TEXT)")
+    for n, (source, stamp) in enumerate(newest.items()):
+        conn.execute("INSERT INTO sessions VALUES (?, ?)", (f"s{n}", source))
+        conn.execute("INSERT INTO messages VALUES (?, ?, ?)", (f"m{n}", f"s{n}", stamp.isoformat()))
+    conn.execute("PRAGMA user_version = 48")
+    conn.commit()
+    conn.close()
+    return path
+
+
+class TestFreshnessNamesTheStaleHarness:
+    """The row said "newest exported message is 48 h old": the newest across ALL
+    harnesses. That hid that Kiro, the harness in daily use, had exported nothing
+    for 22 days, because kiro-cli moved its sessions to ~/.kiro/sessions/cli/,
+    which the exporter does not read (reported 2026-09-27)."""
+
+    NOW = datetime(2026, 9, 27, 12, 0, tzinfo=UTC)
+
+    def test_a_stale_row_lists_every_harness_newest_first(self, tmp_path: Path) -> None:
+        db = _db_by_source(
+            tmp_path / "s.db",
+            {
+                "kiro_cli": self.NOW - timedelta(days=22),
+                "codex": self.NOW - timedelta(hours=48),
+                "pi": self.NOW - timedelta(days=11),
+            },
+        )
+        result = exporter.check_export_freshness(
+            db, now=self.NOW, kiro_sessions_dir=tmp_path / "absent"
+        )
+        assert result.status == "warn"
+        assert "codex 2 d, pi 11 d, kiro_cli 22 d" in result.message
+
+    def test_kiro_sessions_the_exporter_cannot_read_warn_even_when_another_is_fresh(
+        self, tmp_path: Path
+    ) -> None:
+        db = _db_by_source(
+            tmp_path / "s.db",
+            {"codex": self.NOW - timedelta(hours=1), "kiro_cli": self.NOW - timedelta(days=22)},
+        )
+        store = tmp_path / "cli"
+        store.mkdir()
+        (store / "a.jsonl").write_text("{}\n")
+        stamp = (self.NOW - timedelta(hours=1)).timestamp()
+        os.utime(store, (stamp, stamp))
+
+        result = exporter.check_export_freshness(db, now=self.NOW, kiro_sessions_dir=store)
+        assert result.status == "warn"
+        assert str(store) in result.message
+        assert "does not read" in result.message
+        assert "kiro_cli 22 d" in result.message
+
+    def test_a_kiro_store_older_than_the_last_kiro_export_says_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        db = _db_by_source(tmp_path / "s.db", {"kiro_cli": self.NOW - timedelta(hours=2)})
+        store = tmp_path / "cli"
+        store.mkdir()
+        stamp = (self.NOW - timedelta(days=3)).timestamp()
+        os.utime(store, (stamp, stamp))
+
+        result = exporter.check_export_freshness(db, now=self.NOW, kiro_sessions_dir=store)
+        assert result.status == "pass"
diff --git a/packages/studyloop/tests/test_doctor_second_brain.py b/packages/studyloop/tests/test_doctor_second_brain.py
index 1551a10d..2aa61cbc 100644
--- a/packages/studyloop/tests/test_doctor_second_brain.py
+++ b/packages/studyloop/tests/test_doctor_second_brain.py
@@ -124,3 +124,29 @@ def test_registered_only_when_the_section_exists(config, tmp_path, monkeypatch)
     config({"second_brain": {"provider": "obsidian", "vault_path": str(vault)}})
     registered = {fn.__name__ for _category, fn in _get_registry()._checkers}
     assert "check_second_brain" in registered
+
+
+def test_rows_xtiles_say_what_is_installed_and_where_a_server_is_registered(
+    config, tmp_path, monkeypatch
+) -> None:
+    """ "no programmatic backend; prompts and an opt-in assistant skill" read as
+    "the skill still needs installing". ``studyloop install agents`` installs it
+    for every harness; what decides whether it ever offers is an MCP server named
+    ``xtiles`` in the session, so the row now says where one is registered
+    (reported 2026-09-27)."""
+    from studyloop import installers
+
+    config({"second_brain": {"provider": "xtiles"}})
+    hub = tmp_path / "hub"
+    hub.mkdir()
+    monkeypatch.setattr(installers, "XTILES_SKILL_HUB", hub)
+    monkeypatch.setattr(installers, "xtiles_mcp_harnesses", lambda: ["codex"])
+
+    (row,) = check_second_brain()
+    assert "opt-in assistant skill" not in row.message
+    assert "skill is installed" in row.message
+    assert "codex" in row.message
+
+    monkeypatch.setattr(installers, "xtiles_mcp_harnesses", lambda: [])
+    (row,) = check_second_brain()
+    assert "no harness" in row.message.lower()
diff --git a/packages/studyloop/tests/test_mcp_registration.py b/packages/studyloop/tests/test_mcp_registration.py
index 55b20f37..a117f9c1 100644
--- a/packages/studyloop/tests/test_mcp_registration.py
+++ b/packages/studyloop/tests/test_mcp_registration.py
@@ -1018,3 +1018,22 @@ def test_topic_exercises_generic_mcp_example_uses_studyloop_as_server_name() ->
     text = _repo_text("docs/topic-exercises.md")
     assert '"studyloop": {' in text
     assert '"studyloop-mcp": {' not in text
+
+
+def test_xtiles_mcp_harnesses_reads_each_config_for_a_server_named_xtiles(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Read-only report the doctor's xTiles row uses. A missing or unreadable
+    config is simply "not registered there", never an error."""
+    files = {
+        "claude": tmp_path / "claude.json",
+        "kiro": tmp_path / "mcp.json",
+        "codex": tmp_path / "config.toml",
+        "opencode": tmp_path / "absent.json",
+    }
+    files["claude"].write_text(json.dumps({"mcpServers": {"studyloop": {}}}))
+    files["kiro"].write_text(json.dumps({"mcpServers": {"xtiles": {"url": "https://x.invalid"}}}))
+    files["codex"].write_text('[mcp_servers.xtiles]\nurl = "https://x.invalid"\n')
+    monkeypatch.setattr(installers, "_mcp_config_path", lambda tool: files[tool])
+
+    assert installers.xtiles_mcp_harnesses() == ["codex", "kiro"]
diff --git a/packages/studyloop/tests/test_settings_custom.py b/packages/studyloop/tests/test_settings_custom.py
index f0bfebb5..1f3c226d 100644
--- a/packages/studyloop/tests/test_settings_custom.py
+++ b/packages/studyloop/tests/test_settings_custom.py
@@ -933,3 +933,37 @@ def test_known_top_level_keys_covers_the_full_docs_drift_derivation():
     known = known_top_level_keys()
     full_derivation = _known_top_level_keys()
     assert full_derivation <= known, sorted(full_derivation - known)
+
+
+def test_project_aliases_is_a_known_key_because_session_search_reads_it():
+    """agent-session-tools reads ``project_aliases`` from the same config.yaml
+    (``query_utils.build_project_filter``; PROJECT_ALIASES.md). The doctor called
+    it inert and said to delete it -- which would have cut session search off
+    from every aliased path: 732 sessions for one project on the machine that
+    reported it (2026-09-27)."""
+    from studyloop.settings import known_top_level_keys, unknown_top_level_keys
+
+    assert "project_aliases" in known_top_level_keys()
+    assert unknown_top_level_keys({"project_aliases": {"/a": ["/b"]}}) == []
+
+
+def test_every_key_agent_session_tools_reads_directly_is_known():
+    """The class, not the instance: every ``load_config().get("<key>")`` or
+    ``load_config()["<key>"]`` in agent-session-tools names a top-level key that
+    the doctor must not report as unknown. DEFAULT_CONFIG's keys are covered by
+    test_docs_drift; this covers the reads that bypass it."""
+    import re
+
+    import agent_session_tools
+    from studyloop.settings import known_top_level_keys
+
+    pattern = re.compile(r"""load_config\(\)(?:\.get\(|\[)\s*["']([A-Za-z_]+)["']""")
+    package = Path(agent_session_tools.__file__).parent
+    read = {
+        (key, path.name)
+        for path in package.rglob("*.py")
+        for key in pattern.findall(path.read_text(encoding="utf-8"))
+    }
+    assert read, "the scan found no reads; the pattern no longer matches the code"
+    known = known_top_level_keys()
+    assert sorted(pair for pair in read if pair[0] not in known) == []
diff --git a/packages/studyloop/tests/test_voice_backends.py b/packages/studyloop/tests/test_voice_backends.py
index 089e2bd6..54866081 100644
--- a/packages/studyloop/tests/test_voice_backends.py
+++ b/packages/studyloop/tests/test_voice_backends.py
@@ -416,3 +416,26 @@ def test_doctor_reports_the_valid_backend_it_resolved(
 
     assert by_name["backend"].status == "pass"
     assert "openvox" in by_name["backend"].message
+
+
+def test_kokoro_model_files_are_only_reported_for_the_kokoro_backend(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    """Only study-speak's local ``kokoro`` backend reads ~/.cache/kokoro-onnx, and
+    it downloads the files itself on first use. With ``backend: openvox`` the row
+    asked a learner to pre-download about 354 MB that nothing on their machine
+    would read (reported 2026-09-27)."""
+    from studyloop.doctor import voice as doctor_voice
+
+    monkeypatch.setattr(doctor_voice, "_KOKORO_MODEL", tmp_path / "kokoro-v1.0.onnx")
+    monkeypatch.setattr(doctor_voice, "_KOKORO_VOICES", tmp_path / "voices-v1.0.bin")
+    monkeypatch.setattr(doctor_voice, "_openvox_reachable", lambda base_url: True)
+
+    monkeypatch.setattr(doctor_voice, "load_raw_config", lambda: {"tts": {"backend": "openvox"}})
+    assert "kokoro_models" not in {r.name for r in doctor_voice.check_voice_readiness()}
+
+    monkeypatch.setattr(doctor_voice, "load_raw_config", lambda: {"tts": {"backend": "kokoro"}})
+    row = {r.name: r for r in doctor_voice.check_voice_readiness()}["kokoro_models"]
+    assert row.status == "info"
+    assert "first use" in row.message
+    assert "MB" in row.message
diff --git a/packages/studyloop/tests/test_web_header_controls.py b/packages/studyloop/tests/test_web_header_controls.py
new file mode 100644
index 00000000..6f3b16e2
--- /dev/null
+++ b/packages/studyloop/tests/test_web_header_controls.py
@@ -0,0 +1,98 @@
+"""The header's controls read as one row of labelled fields.
+
+Reported 2026-09-27 with a screenshot of the header: the voice-engine badge
+("System voices") rendered as large bold text between the voice and theme
+pickers, and those two pickers had no visible label while Font and Size did.
+
+Cause: the badge's classes (``tts-engine-badge`` plus ``pending``/``ok``/
+``degraded``, assigned by ``ttsEngineClass`` in components.js) had no CSS rule
+at all from the commit that added the badge (de7e870b), so the span inherited
+the header's text styles. It is the same unbacked-class slip the
+``.header-field`` comment in style.css already records, which is why the first
+test reads every state the script can assign instead of naming one selector.
+"""
+
+from __future__ import annotations
+
+import re
+from html.parser import HTMLParser
+from pathlib import Path
+
+STATIC = Path(__file__).resolve().parents[1] / "src" / "studyloop" / "web" / "static"
+
+
+class _HeaderFields(HTMLParser):
+    """Collect the header's ``.header-field`` groups: label text, pickers, badge."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.depth = 0
+        self.field_depth: int | None = None
+        self.label_depth: int | None = None
+        self.fields: list[dict] = []
+        self.loose_selects: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.depth += 1
+        attr = {key: value or "" for key, value in attrs}
+        classes = attr.get("class", "").split()
+        if "header-field" in classes and self.field_depth is None:
+            self.field_depth = self.depth
+            self.fields.append({"label": "", "selects": [], "badge": False})
+        elif self.field_depth is not None and "header-field-label" in classes:
+            self.label_depth = self.depth
+        if tag == "select":
+            name = attr.get("id") or attr.get("title", "")
+            if self.field_depth is None:
+                self.loose_selects.append(name)
+            else:
+                self.fields[-1]["selects"].append(name)
+        if attr.get("id") == "tts-engine-badge" and self.field_depth is not None:
+            self.fields[-1]["badge"] = True
+
+    def handle_endtag(self, tag: str) -> None:
+        if self.label_depth == self.depth:
+            self.label_depth = None
+        if self.field_depth == self.depth:
+            self.field_depth = None
+        self.depth -= 1
+
+    def handle_data(self, data: str) -> None:
+        if self.label_depth is not None:
+            self.fields[-1]["label"] += data.strip()
+
+
+def _header() -> _HeaderFields:
+    html = (STATIC / "index.html").read_text(encoding="utf-8")
+    start = html.index('<div class="header-controls">')
+    end = html.index("</header>", start)
+    parser = _HeaderFields()
+    parser.feed(html[start:end])
+    parser.close()
+    assert parser.depth == 0, "the header controls did not parse as balanced elements"
+    return parser
+
+
+def test_every_state_the_script_assigns_the_voice_badge_has_a_style() -> None:
+    script = (STATIC / "components.js").read_text(encoding="utf-8")
+    states = set(re.findall(r"'tts-engine-badge (\w+)'", script))
+    assert states == {"pending", "ok", "degraded"}, f"the class seam moved: {states}"
+
+    css = (STATIC / "style.css").read_text(encoding="utf-8")
+    assert re.search(r"(^|\n)\.tts-engine-badge\s*\{", css), "no rule for the badge itself"
+    for state in sorted(states):
+        assert re.search(rf"\.tts-engine-badge\.{state}\s*\{{", css), f"no rule for .{state}"
+
+
+def test_every_header_picker_has_a_visible_label_in_reading_order() -> None:
+    header = _header()
+    assert header.loose_selects == [], f"pickers with no visible label: {header.loose_selects}"
+    assert [field["label"] for field in header.fields] == ["Voice", "Theme", "Font", "Size"]
+    assert all(len(field["selects"]) == 1 for field in header.fields)
+
+
+def test_the_voice_badge_sits_in_the_voice_field() -> None:
+    header = _header()
+    voice = next(field for field in header.fields if field["selects"] == ["voice-select"])
+    assert voice["badge"], "the engine badge floats outside the voice field"
+    assert sum(field["badge"] for field in header.fields) == 1
diff --git a/packages/studyloop/tests/test_web_layout_regression.py b/packages/studyloop/tests/test_web_layout_regression.py
index 37971610..d11a13aa 100644
--- a/packages/studyloop/tests/test_web_layout_regression.py
+++ b/packages/studyloop/tests/test_web_layout_regression.py
@@ -863,3 +863,145 @@ def test_tts_button_appears_when_engine_injected(self, web_page: Page) -> None:
         )
         assert state["ttsAvailable"] is True, "ttsAvailable must be true when engine injected"
         assert state["btnVisible"] is True, "read-aloud button must appear when TTS present"
+
+
+# ---------------------------------------------------------------------------
+# App header — one line of controls on the brand's centre line (2026-09-28)
+# ---------------------------------------------------------------------------
+#
+# Reported twice with a screenshot: "the top panel of the web ui is still not
+# neat/central/aligned". The first fix (labels on every picker, one bottom edge)
+# was checked only by parsing the HTML and CSS, and measured in a browser it was
+# still wrong in three ways: the voice picker was 25.5px tall beside 31px
+# buttons and 32px pickers, the voice label sat 3px lower than the others
+# because the engine pill made its row taller, and the whole row sat 6.5px below
+# the brand. At a 1024px tablet width, with the semantic chip showing, the
+# controls also ran 70px past the window and under the brand. These tests
+# measure the rendered header, which is the only thing the learner sees.
+
+# Every label ttsEngineLabel can produce, so the widest one is always covered.
+_ENGINE_TIERS = (None, "server-openvox", "web-speech", "silent")
+
+_HEADER_GEOMETRY_JS = """async (tier) => {
+  const settings = window.Alpine.store('settings');
+  settings.ttsTier = tier;
+  await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+  const shown = (el) => {
+    const r = el.getBoundingClientRect();
+    return r.width > 0 && r.height > 0 && getComputedStyle(el).visibility !== 'hidden';
+  };
+  const box = (el) => {
+    const r = el.getBoundingClientRect();
+    return {top: r.top, bottom: r.bottom, left: r.left, right: r.right,
+            height: r.height, cy: r.top + r.height / 2,
+            name: el.id || el.getAttribute('title') || el.textContent.trim().slice(0, 24)};
+  };
+  const header = document.querySelector('body > header');
+  const controls = [...header.querySelectorAll(
+    '.header-controls button, .header-controls select')].filter(shown).map(box);
+  const labels = [...header.querySelectorAll(
+    '.header-field-label, #tts-engine-badge')].filter(shown).map(box);
+  return {badge: document.querySelector('#tts-engine-badge').textContent.trim(),
+          header: box(header), brand: box(header.querySelector('.brand')),
+          controls, labels,
+          scrollWidth: document.documentElement.scrollWidth,
+          innerWidth: window.innerWidth};
+}"""
+
+
+def _open_header_worst_case(page: Page, width: int, height: int) -> None:
+    """Every optional header item at once: voice on (adds the voice field and
+    its engine badge) and the semantic chip showing a failure."""
+    page.route(
+        "**/api/retrieval/health",
+        lambda route: _fulfill(
+            route, {"state": "failed", "model": "bge-small", "elapsed": 3.6, "detail": ""}
+        ),
+    )
+    page.set_viewport_size({"width": width, "height": height})
+    _goto(page, "today")
+    page.evaluate(
+        "() => { const s = window.Alpine.store('settings'); if (!s.voiceOn) s.toggleVoice(); }"
+    )
+    page.wait_for_selector("#voice-select", state="visible", timeout=5000)
+    page.wait_for_selector("#encoder-warm-chip", state="visible", timeout=5000)
+    page.wait_for_timeout(300)
+
+
+def _rows(boxes: list[dict]) -> list[list[dict]]:
+    """Group boxes into visual rows: a box starts a new row once it begins
+    below every box of the current one."""
+    rows: list[list[dict]] = []
+    for item in sorted(boxes, key=lambda b: b["top"]):
+        if rows and item["top"] < max(b["bottom"] for b in rows[-1]):
+            rows[-1].append(item)
+        else:
+            rows.append([item])
+    return rows
+
+
+def _overlaps(a: dict, b: dict, slack: float = 0.5) -> bool:
+    return (
+        a["left"] < b["right"] - slack
+        and b["left"] < a["right"] - slack
+        and a["top"] < b["bottom"] - slack
+        and b["top"] < a["bottom"] - slack
+    )
+
+
+def _assert_header_neat(geo: dict, *, single_row: bool) -> None:
+    where = f"(badge {geo['badge']!r}, window {geo['innerWidth']}px)"
+    controls, labels, header = geo["controls"], geo["labels"], geo["header"]
+    assert controls, f"no header controls were measured {where}"
+
+    overflow = geo["scrollWidth"] - geo["innerWidth"]
+    assert overflow <= 0, (
+        f"the header pushes the page {overflow:.0f}px wider than the window {where}"
+    )
+
+    heights = sorted({round(c["height"], 1) for c in controls})
+    assert heights[-1] - heights[0] <= 1, f"header controls are not one height: {heights} {where}"
+
+    rows = _rows(controls)
+    for row in rows:
+        centres = [c["cy"] for c in row]
+        assert max(centres) - min(centres) <= 1, (
+            "controls in one row are not on one line: "
+            f"{[(c['name'], round(c['cy'], 1)) for c in row]} {where}"
+        )
+    if single_row:
+        assert len(rows) == 1, f"the controls wrapped into {len(rows)} rows {where}"
+        drift = rows[0][0]["cy"] - geo["brand"]["cy"]
+        assert abs(drift) <= 1.5, (
+            f"the controls sit {drift:+.1f}px off the brand's centre line {where}"
+        )
+
+    for label in labels:
+        assert label["top"] >= header["top"] - 0.5 and label["bottom"] <= header["bottom"] + 0.5, (
+            f"label {label['name']!r} spills out of the header {where}"
+        )
+    for row in _rows(labels):
+        bottoms = [label["bottom"] for label in row]
+        assert max(bottoms) - min(bottoms) <= 1, (
+            "field labels in one row do not share a bottom edge: "
+            f"{[(label['name'], round(label['bottom'], 1)) for label in row]} {where}"
+        )
+
+    boxes = controls + labels
+    for i, first in enumerate(boxes):
+        for second in boxes[i + 1 :]:
+            assert not _overlaps(first, second), (
+                f"{first['name']!r} overlaps {second['name']!r} {where}"
+            )
+
+
+class TestHeaderControlsLayout:
+    def test_one_line_of_controls_on_the_brand_centre_at_laptop_width(self, web_page: Page) -> None:
+        _open_header_worst_case(web_page, 1440, 900)
+        for tier in _ENGINE_TIERS:
+            _assert_header_neat(web_page.evaluate(_HEADER_GEOMETRY_JS, tier), single_row=True)
+
+    def test_the_header_fits_a_tablet_width_without_overlap(self, web_page: Page) -> None:
+        _open_header_worst_case(web_page, 1024, 768)
+        for tier in _ENGINE_TIERS:
+            _assert_header_neat(web_page.evaluate(_HEADER_GEOMETRY_JS, tier), single_row=False)
diff --git a/packages/studyloop/tests/test_web_static_cache.py b/packages/studyloop/tests/test_web_static_cache.py
new file mode 100644
index 00000000..bc0474a7
--- /dev/null
+++ b/packages/studyloop/tests/test_web_static_cache.py
@@ -0,0 +1,60 @@
+"""Static assets are revalidated on every load, like the page that uses them.
+
+Found 2026-09-28 while checking a header fix in a browser: after the CSS on
+disk changed, a reload still drew the old header. ``/`` is served with
+``no-cache, no-store, must-revalidate``, but the static mount behind it sent
+``style.css``, ``components.js`` and every ``js/`` module with only an ETag and
+Last-Modified. With no Cache-Control a browser applies heuristic freshness,
+commonly a tenth of the file's age, so a stylesheet unchanged for three weeks is
+reused for about two days without asking the server. After ``git pull`` the
+learner gets the new index.html beside the old CSS and JS: a fix that looks as
+if it never landed, or markup the old script does not understand.
+
+``no-cache`` does not mean "do not cache": the browser keeps its copy and asks
+first, and an unchanged file costs a 304.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("fastapi")
+
+
+def _client():
+    from fastapi.testclient import TestClient
+
+    from studyloop.web.app import create_app
+
+    return TestClient(create_app())
+
+
+@pytest.mark.parametrize(
+    "path",
+    [
+        "/style.css",
+        "/components.js",
+        "/js/retrieval-chip.js",
+        "/js/components/live-agent-console.js",
+    ],
+)
+def test_static_assets_are_revalidated_before_reuse(path: str) -> None:
+    response = _client().get(path)
+    assert response.status_code == 200, f"{path} -> {response.status_code}"
+    directives = {
+        part.strip().lower() for part in response.headers.get("cache-control", "").split(",")
+    }
+    assert "no-cache" in directives, (
+        f"{path} carries no Cache-Control: no-cache "
+        f"(got {response.headers.get('cache-control')!r}), so a browser may reuse a "
+        "stale copy after an update without asking the server"
+    )
+
+
+def test_an_unchanged_asset_still_costs_only_a_304() -> None:
+    client = _client()
+    first = client.get("/style.css")
+    etag = first.headers.get("etag")
+    assert etag, "revalidation needs a validator"
+    again = client.get("/style.css", headers={"If-None-Match": etag})
+    assert again.status_code == 304