Fix bulk actions, create chats lazily, rework the UI

Seven reported problems.

**Bulk model actions 404'd.** /admin/models/{model_id} was registered
before /admin/models/bulk, and FastAPI matches in registration order, so
"bulk" was parsed as a model id. Moved above the parameterised route,
with a comment saying why, and a regression test.

**Empty chats piled up.** There is now no endpoint that creates one.
"New chat" is a link to /chat, which renders a composer with no row
behind it, and POST /api/chats/start writes the chat together with its
first message. Opening one and walking away leaves nothing.

**Pinning meant two different things.** The picker is now always in the
administrator's position order; pinned models get shortcuts in the chat
sidebar and nothing else. A picker whose order silently differs from the
admin screen is just confusing.

**Model images were missing in chat.** Assistant bubbles now show the
avatar of the model that actually wrote the turn -- which is not always
the model the chat is set to now -- falling back to the LLeMbas mark.
The picker shows it too.

**No global or per-model system prompt.** Three layers now: instance
(Admin -> General), model (Admin -> Models), chat. Precedence, not
concatenation: most specific wins outright. Stacking them reads well in
a settings screen and badly in practice, because two layers that
disagree give the model contradictory instructions and nobody can tell
which is losing. The chat panel shows the inherited prompt as
placeholder text so "leave empty to inherit" is not a guess.

**Alignment and button sizing.** Added --control-h and friends to
tokens.css; every button, input and select takes its height from them,
so a mixed row is flush by construction rather than by per-instance
nudging. Icon buttons are square at that height. Added .btn-row,
.card__header/.card__footer and .grid so pages stop carrying inline
styles, and moved every admin page onto them.

**Settings needed structure.** The user settings page is now tabbed
(Account / Models / Appearance / Security) using radio inputs and
sibling selectors -- no JavaScript, and the browser keeps the chosen tab
across a re-render.

Caught while checking: the chat.css surgery had deleted the attachment,
chip and dropzone rules. Restored, and there is now a check that every
literal class used in a template has a CSS rule.

197 tests, ruff clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/lembas/services/chat.py

@@ -129,6 +129,32 @@ def message_payload(message: Message, *, vision: bool) -> dict[str, Any]:
     return {"role": message.role, "content": parts}
 
 
+def effective_system_prompt(db: DBSession, chat: Chat) -> str:
+    """The system prompt a chat actually runs with.
+
+    Three layers, most specific wins outright:
+
+        chat  >  model  >  instance
+
+    Precedence rather than concatenation. Stacking them reads well in a
+    settings screen and badly in practice: the moment two layers disagree the
+    model gets contradictory instructions and nobody can tell which one is
+    losing. With precedence, "why is it behaving like this" has one answer.
+    """
+    from lembas.services import settings_store
+
+    if chat.system_prompt.strip():
+        return chat.system_prompt.strip()
+
+    model = db.scalar(
+        select(Model).where(Model.model_id == chat.model_id).order_by(Model.position)
+    )
+    if model is not None and (model.system_prompt or "").strip():
+        return model.system_prompt.strip()
+
+    return (settings_store.get(db, "system_prompt") or "").strip()
+
+
 def build_messages(
     db: DBSession, chat: Chat, *, upto: Message | None = None, vision: bool = False
 ) -> list[dict]:
@@ -138,8 +164,9 @@ def build_messages(
     everything after it.
     """
     payload: list[dict[str, Any]] = []
-    if chat.system_prompt.strip():
-        payload.append({"role": ROLE_SYSTEM, "content": chat.system_prompt.strip()})
+    system = effective_system_prompt(db, chat)
+    if system:
+        payload.append({"role": ROLE_SYSTEM, "content": system})
 
     history = db.scalars(
         select(Message).where(Message.chat_id == chat.id).order_by(Message.created_at)
@@ -209,18 +236,23 @@ def default_model(db: DBSession, user=None) -> tuple[str, str] | None:
     if instance_default and instance_default in by_id:
         return instance_default, by_id[instance_default].connection_id
 
-    # Pinned models sort first, matching what the picker shows at the top.
-    ordered = sorted(reachable, key=lambda m: (not m.pinned, m.position, m.model_id))
-    chosen = ordered[0]
+    # First in the administrator's ordering. Pinning is a sidebar shortcut, not
+    # a reordering, so it deliberately does not influence this.
+    chosen = sorted(reachable, key=lambda m: (m.position, m.model_id))[0]
     return chosen.model_id, chosen.connection_id
 
 
 def available_models(db: DBSession, user=None) -> list[Model]:
-    """Models this user may start a chat with, pinned first."""
+    """Models this user may start a chat with, in the administrator's order.
+
+    Pinning does NOT hoist a model up this list: pinned models get their own
+    shortcuts in the sidebar, and a picker whose order silently differs from
+    the one configured in the admin screen is just confusing.
+    """
     from lembas.security import permissions
 
     reachable = permissions.models_visible_to(db, user)
-    return sorted(reachable, key=lambda m: (not m.pinned, m.position, m.model_id))
+    return sorted(reachable, key=lambda m: (m.position, m.model_id))
 
 
 def fallback_title(text: str) -> str: