diff --git a/README.md b/README.md
index cf1eb53..afc7b63 100644
--- a/README.md
+++ b/README.md
@@ -134,8 +134,10 @@ deploy/               # dashboard.service
 ```
 
 Adding a plugin: create a module in `app/plugins/` defining a `Plugin`
-instance (id, title, poll interval, fragment function) and register it in
-`app/plugins/__init__.py`.
+instance (id, title, skeleton function) and register it in
+`app/plugins/__init__.py`. The skeleton is the static card shell, rendered
+once; it embeds the dynamically polled regions (e.g. a div with
+`hx-get`/`hx-trigger="every Ns"` pointing at the plugin's own endpoints).
 
 ## License
 
diff --git a/app/plugins/base.py b/app/plugins/base.py
index b3e2a03..1506343 100644
--- a/app/plugins/base.py
+++ b/app/plugins/base.py
@@ -7,10 +7,9 @@ class Plugin:
     id: str
     title: str
     description: str = ""
-    poll_seconds: int = 5
-    fragment_fn: Callable[[], Awaitable[str]] | None = field(default=None)
+    skeleton_fn: Callable[[], Awaitable[str]] | None = field(default=None)
 
-    async def fragment(self) -> str:
-        if self.fragment_fn is None:
+    async def skeleton(self) -> str:
+        if self.skeleton_fn is None:
             raise NotImplementedError
-        return await self.fragment_fn()
+        return await self.skeleton_fn()
diff --git a/app/plugins/llamacpp.py b/app/plugins/llamacpp.py
index f8e12fe..6d955c8 100644
--- a/app/plugins/llamacpp.py
+++ b/app/plugins/llamacpp.py
@@ -87,28 +87,40 @@ async def _action(endpoint: str, model: str) -> tuple[bool, str]:
         return False, f"unreachable: {e.__class__.__name__}"
 
 
-async def _fragment(message: str = "", error: str = "") -> str:
-    status = await gather_status()
-    status["message"] = message
-    status["error_msg"] = error
+def _with_lists(status: dict[str, Any]) -> dict[str, Any]:
     active = {m["id"] for m in status["models"] if m["state"] in ("loaded", "sleeping", "loading")}
     status["loaded"] = [m for m in status["models"] if m["id"] in active]
     status["available"] = [m for m in status["models"] if m["id"] not in active]
     status["loaded"].sort(key=lambda m: (m["state"] != "loaded", m["state"] != "sleeping", m["id"]))
     status["available"].sort(key=lambda m: m["id"])
-    return render("plugins/llamacpp.html", **status)
+    return status
 
 
-@router.get("/fragment")
-async def fragment():
-    return HTMLResponse(await _fragment())
+async def _status(message: str, error: str) -> dict[str, Any]:
+    status = _with_lists(await gather_status())
+    status["message"] = message
+    status["error_msg"] = error
+    return status
+
+
+async def _state(message: str = "", error: str = "") -> str:
+    return render("plugins/llamacpp_state.html", **await _status(message, error))
+
+
+async def _skeleton(message: str = "", error: str = "") -> str:
+    return render("plugins/llamacpp_skeleton.html", **await _status(message, error))
+
+
+@router.get("/state")
+async def state():
+    return HTMLResponse(await _state())
 
 
 @router.post("/load")
 async def load(model: str = Form(...)):
     ok, err = await _action("/models/load", model)
     return HTMLResponse(
-        await _fragment(
+        await _skeleton(
             message=f"loading {model}" if ok else "",
             error="" if ok else err,
         )
@@ -119,7 +131,7 @@ async def load(model: str = Form(...)):
 async def unload(model: str = Form(...)):
     ok, err = await _action("/models/unload", model)
     return HTMLResponse(
-        await _fragment(
+        await _skeleton(
             message=f"unloading {model}" if ok else "",
             error="" if ok else err,
         )
@@ -138,13 +150,12 @@ async def rescan():
                 msg, err = "", f"http {r.status_code}"
     except httpx.HTTPError as e:
         msg, err = "", f"unreachable: {e.__class__.__name__}"
-    return HTMLResponse(await _fragment(message=msg, error=err))
+    return HTMLResponse(await _skeleton(message=msg, error=err))
 
 
 plugin = Plugin(
     id="llamacpp",
     title="llama.cpp",
     description="Loaded model status for a llama-server in router mode, with load / unload controls.",
-    poll_seconds=5,
-    fragment_fn=_fragment,
+    skeleton_fn=_skeleton,
 )
diff --git a/app/routers/plugins.py b/app/routers/plugins.py
index 860eed7..e9ac9d8 100644
--- a/app/routers/plugins.py
+++ b/app/routers/plugins.py
@@ -12,16 +12,8 @@ async def plugins_index():
     items: list[dict[str, Plugin | str]] = []
     for p in PLUGINS:
         try:
-            frag = await p.fragment()
+            body = await p.skeleton()
         except Exception as e: # noqa
-            frag = f"<div class='alert'>plugin error: {e}</div>"
-        items.append({"p": p, "frag": frag})
+            body = f"<div class='alert'>plugin error: {e}</div>"
+        items.append({"p": p, "body": body})
     return HTMLResponse(render("plugins.html", items=items))
-
-
-@router.get("/{pid}/fragment")
-async def plugin_fragment(pid: str):
-    plugin = next((p for p in PLUGINS if p.id == pid), None)
-    if plugin is None:
-        return HTMLResponse("unknown plugin", status_code=404)
-    return HTMLResponse(await plugin.fragment())
diff --git a/opencode_session_plugin_skeleton_2026-08-30.txt b/opencode_session_plugin_skeleton_2026-08-30.txt
new file mode 100644
index 0000000..1acd5d9
--- /dev/null
+++ b/opencode_session_plugin_skeleton_2026-08-30.txt
@@ -0,0 +1,2283 @@
+mac  2026-08-29 19:48:20 → now  1 session(s)
+
+Session  Started           Where           Title
+JY7woN   2026-08-30 19:23  Code/dashboard  Fragment partial refresh split
+
+
+ ⚑ ❬JY7woN❭ Fragment partial refresh split                                          ~/Code/dashboard
+────────────────────────────────────────────────────────────────────────────────────────────────────
+
+  │ 2026-08-30 19:23:28 • user
+  │
+  │ The plugins' fragments reload completely on an automated schedule, we need to split that into a
+  │ static part and a dynamic part that refreshes automatically. With the automated refresh of the
+  │ whole fragment it is really hard to select something in a dropdown; it is possible the fragment
+  │ reloads while the user is choosing an option.
+
+
+  │ 2026-08-30 19:23:28 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Let's start by understanding the codebase. The user is saying that the plugin fragment is being
+  │ completely reloaded on a schedule. I need to find where the plugin's template and router are,
+  │ understand how the htmx polling works, and then propose a plan to split it into static and
+  │ dynamic parts.
+  │
+  │ Let's read the relevant files: app/plugins/, app/routers/plugins.py (or similar file),
+  │ templates/plugins*.html, and the llamacpp plugin to understand what parts are static and what
+  │ parts are dynamic.
+  │
+  │ Let's explore.
+  │
+  │ glob app/plugins/**                                                                  ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "app/plugins/**"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/app/plugins/base.py
+  │     /home/mac/Code/dashboard/app/plugins/__init__.py
+  │     /home/mac/Code/dashboard/app/plugins/__pycache__/llamacpp.cpython-314.pyc
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py
+  │     /home/mac/Code/dashboard/app/plugins/__pycache__/__init__.cpython-314.pyc
+  │     /home/mac/Code/dashboard/app/plugins/__pycache__/base.cpython-314.pyc
+  │ glob app/routers/*                                                                   ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "app/routers/*"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/app/routers/disks.py
+  │     /home/mac/Code/dashboard/app/routers/overview.py
+  │     /home/mac/Code/dashboard/app/routers/services.py
+  │     /home/mac/Code/dashboard/app/routers/plugins.py
+  │     /home/mac/Code/dashboard/app/routers/journal.py
+  │     /home/mac/Code/dashboard/app/routers/__init__.py
+  │     /home/mac/Code/dashboard/app/routers/processes.py
+  │ glob templates/*                                                                     ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "templates/*"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/templates/index.html
+  │     /home/mac/Code/dashboard/templates/overview.html
+  │     /home/mac/Code/dashboard/templates/journal.html
+  │     /home/mac/Code/dashboard/templates/processes.html
+  │     /home/mac/Code/dashboard/templates/disks.html
+  │     /home/mac/Code/dashboard/templates/service_detail.html
+  │     /home/mac/Code/dashboard/templates/services.html
+  │     /home/mac/Code/dashboard/templates/plugins.html
+  │
+  │ tokens 545 in 198 out 8713 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:23:37 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Let's try reading the plugin router, base plugin, llamacpp plugin, and the template.
+  │
+  │ read /home/mac/Code/dashboard/app/routers/plugins.py                                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/routers/plugins.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/routers/plugins.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from fastapi import APIRouter
+  │     2: from fastapi.responses import HTMLResponse
+  │     3:
+  │     4: from app.plugins import PLUGINS, Plugin
+  │     5: from app.render import render
+  │     6:
+  │     7: router = APIRouter(prefix="/api/plugins", tags=["plugins"])
+  │     8:
+  │     9:
+  │     10: @router.get("")
+  │     11: async def plugins_index():
+  │     12:     items: list[dict[str, Plugin | str]] = []
+  │     13:     for p in PLUGINS:
+  │     14:         try:
+  │     15:             frag = await p.fragment()
+  │     16:         except Exception as e: # noqa
+  │     17:             frag = f"<div class='alert'>plugin error: {e}</div>"
+  │     18:         items.append({"p": p, "frag": frag})
+  │     19:     return HTMLResponse(render("plugins.html", items=items))
+  │     20:
+  │     21:
+  │     22: @router.get("/{pid}/fragment")
+  │     23: async def plugin_fragment(pid: str):
+  │     24:     plugin = next((p for p in PLUGINS if p.id == pid), None)
+  │     25:     if plugin is None:
+  │     26:         return HTMLResponse("unknown plugin", status_code=404)
+  │     27:     return HTMLResponse(await plugin.fragment())
+  │
+  │     (End of file - total 27 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/app/plugins/base.py                                    ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/base.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/plugins/base.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from collections.abc import Awaitable, Callable
+  │     2: from dataclasses import dataclass, field
+  │     3:
+  │     4:
+  │     5: @dataclass
+  │     6: class Plugin:
+  │     7:     id: str
+  │     8:     title: str
+  │     9:     description: str = ""
+  │     10:     poll_seconds: int = 5
+  │     11:     fragment_fn: Callable[[], Awaitable[str]] | None = field(default=None)
+  │     12:
+  │     13:     async def fragment(self) -> str:
+  │     14:         if self.fragment_fn is None:
+  │     15:             raise NotImplementedError
+  │     16:         return await self.fragment_fn()
+  │
+  │     (End of file - total 16 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/plugins/llamacpp.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from typing import Any
+  │     2:
+  │     3: import httpx
+  │     4: from fastapi import APIRouter, Form
+  │     5: from fastapi.responses import HTMLResponse
+  │     6:
+  │     7: from app.config import Settings, get_settings
+  │     8: from app.plugins.base import Plugin
+  │     9: from app.render import render
+  │     10:
+  │     11: router = APIRouter(prefix="/api/plugins/llamacpp", tags=["plugins"])
+  │     12:
+  │     13:
+  │     14: def _headers(settings: Settings) -> dict[str, str]:
+  │     15:     h = {}
+  │     16:     if settings.llama_api_key:
+  │     17:         h["Authorization"] = f"Bearer {settings.llama_api_key}"
+  │     18:     return h
+  │     19:
+  │     20:
+  │     21: def _client() -> httpx.AsyncClient:
+  │     22:     settings = get_settings()
+  │     23:     return httpx.AsyncClient(
+  │     24:         base_url=settings.llama_base_url.rstrip("/"),
+  │     25:         timeout=settings.llama_timeout,
+  │     26:         headers=_headers(settings),
+  │     27:     )
+  │     28:
+  │     29:
+  │     30: async def gather_status() -> dict[str, Any]:
+  │     31:     """Query the llama-server router. Never raises; returns status dict."""
+  │     32:     settings = get_settings()
+  │     33:     status: dict[str, Any] = {
+  │     34:         "base_url": settings.llama_base_url,
+  │     35:         "reachable": False,
+  │     36:         "health": None,
+  │     37:         "models": [],
+  │     38:         "error": None,
+  │     39:     }
+  │     40:     try:
+  │     41:         async with _client() as client:
+  │     42:             try:
+  │     43:                 r = await client.get("/health")
+  │     44:                 status["health"] = r.json().get("status") if r.status_code == 200 else
+  │     f"http {r.status_code}"
+  │     45:             except httpx.HTTPError:
+  │     46:                 pass
+  │     47:             r = await client.get("/models")
+  │     48:             _ = r.raise_for_status()
+  │     49:             status["reachable"] = True
+  │     50:             data = r.json()
+  │     51:             for m in data.get("data", []):
+  │     52:                 st: dict[str, Any] = m.get("status") or {}
+  │     53:                 item: dict[str, str | bool | float] = {
+  │     54:                     "id": str(m.get("id", "?")),
+  │     55:                     "sta
+  │     … [3871 more chars]
+  │ read /home/mac/Code/dashboard/templates/plugins.html                                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="plugins" class="panel">
+  │     2:   <div class="muted small">plugins load from <span class="mono">app/plugins/</span>
+  │     &mdash; each module exposes a <span class="mono">Plugin</span> instance</div>
+  │     3:   {% for item in items %}
+  │     4:   <div class="plugin-card">
+  │     5:     <h3>{{ item.p.title }}</h3>
+  │     6:     <p class="muted small">{{ item.p.description }}</p>
+  │     7:     <div class="plugin-body" hx-get="/api/plugins/{{ item.p.id }}/fragment"
+  │     hx-trigger="every {{ item.p.poll_seconds }}s" hx-swap="innerHTML">{{ item.frag | safe
+  │     }}</div>
+  │     8:   </div>
+  │     9:   {% else %}
+  │     10:   <div class="muted">no plugins registered</div>
+  │     11:   {% endfor %}
+  │     12: </div>
+  │
+  │     (End of file - total 12 lines)
+  │     </content>
+  │
+  │ tokens 284 in 158 out 9456 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:23:41 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Alright, let's take a look at the llamacpp.html template to see what's in there — the static
+  │ part (buttons, labels, dropdown container) and the dynamic part (the dropdown options
+  │ themselves, the model list).
+  │
+  │ glob templates/plugins/*                                                             ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "templates/plugins/*"
+  │     }
+  │   out /home/mac/Code/dashboard/templates/plugins/llamacpp.html
+  │
+  │ tokens 2711 in 77 out 9899 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:23:46 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Let's read the llamacpp.html template and understand the structure.
+  │
+  │ read /home/mac/Code/dashboard/templates/plugins/llamacpp.html                        ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/llamacpp.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="llama">
+  │     2:   {% if not reachable %}
+  │     3:   <div class="alert">llama-server unreachable at <span class="mono">{{ base_url
+  │     }}</span>{% if error %}: {{ error }}{% endif %}</div>
+  │     4:   <div class="muted small">start it in router mode: <span class="mono">llama-server
+  │     --models-dir /path/to/models</span></div>
+  │     5:   {% else %}
+  │     6:   <div class="llama-health">
+  │     7:     <span class="dot {{ "dot-run" if health == "ok" else "dot-failed" }}"></span>
+  │     8:     <span class="llama-health-text">{{ "healthy" if health == "ok" else (health or
+  │     "status unknown") }}</span>
+  │     9:     <span class="muted small mono">{{ base_url }}</span>
+  │     10:   </div>
+  │     11:   {% if message %}<div class="notice">{{ message }}</div>{% endif %}
+  │     12:   {% if error_msg %}<div class="alert">{{ error_msg }}</div>{% endif %}
+  │     13:
+  │     14:   <h4>Loaded models</h4>
+  │     15:   {% if loaded %}
+  │     16:   <div class="llama-models">
+  │     17:     {% for m in loaded %}
+  │     18:     <div class="llama-model">
+  │     19:       <span class="dot {{ "dot-run" if m.state == "loaded" else ("dot-sleep" if m.state
+  │     == "sleeping" else ("dot-failed" if m.failed else "dot-busy")) }}"></span>
+  │     20:       <span class="mono llama-id" title="{{ m.path }}">{{ m.id }}</span>
+  │     21:       <span class="badge badge-{{ "failed" if m.failed else m.state }}">{{ m.state }}{%
+  │     if m.failed %} (exit {{ m.exit_code }}){% endif %}</span>
+  │     22:       {% if m.progress is not none %}<div class="bar small-bar"><div class="bar-fill"
+  │     style="width: {{ m.progress }}%"></div></div>{% endif %}
+  │     23:       <span class="llama-model-actions">
+  │     24:         <button class="btn" hx-post="/api/plugins/llamacpp/unload" hx-vals='{"model":"{{
+  │     m.id }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML" hx-confirm="Unload {{ m.id
+  │     }}?">unload</button>
+  │     25:       </span>
+  │     26:     </div>
+  │     27:     {% endfor %}
+  │     28:   </div>
+  │     29:   {% else %}
+  │     30:   <div class="muted small">no models loaded</div>
+  │     31:   {% endif %}
+  │     32:
+  │     33:   <h4>A
+  │     … [887 more chars]
+  │ read /home/mac/Code/dashboard/app/plugins/__init__.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/__init__.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/plugins/__init__.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from app.plugins.base import Plugin
+  │     2: from app.plugins.llamacpp import plugin as llamacpp_plugin, router as llamacpp_router
+  │     3:
+  │     4: PLUGINS: list[Plugin] = [llamacpp_plugin]
+  │     5: ROUTERS = [llamacpp_router]
+  │     6:
+  │     7: __all__ = ["PLUGINS", "ROUTERS", "Plugin"]
+  │
+  │     (End of file - total 7 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/app/render.py                                          ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/render.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/render.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from datetime import timedelta
+  │     2: from pathlib import Path
+  │     3: from typing import Any
+  │     4:
+  │     5: from jinja2 import Environment, FileSystemLoader, select_autoescape
+  │     6:
+  │     7: BASE = Path(__file__).resolve().parent.parent
+  │     8:
+  │     9:
+  │     10: def humanize(value: float | str | None) -> str:
+  │     11:     if value is None:
+  │     12:         return "—"
+  │     13:     n = float(value)
+  │     14:     for unit in ("B", "KiB", "MiB", "GiB", "TiB"):
+  │     15:         if abs(n) < 1024 or unit == "TiB":
+  │     16:             if unit == "B":
+  │     17:                 return f"{int(n)} B"
+  │     18:             return f"{n:.1f} {unit}"
+  │     19:         n /= 1024
+  │     20:     return f"{n:.1f} TiB"
+  │     21:
+  │     22:
+  │     23: def rate(value: float | str | None) -> str:
+  │     24:     if value is None:
+  │     25:         return "—"
+  │     26:     n = float(value)
+  │     27:     for unit in ("B/s", "KiB/s", "MiB/s", "GiB/s"):
+  │     28:         if abs(n) < 1024 or unit == "GiB/s":
+  │     29:             if unit == "B/s":
+  │     30:                 return f"{int(n)} B/s"
+  │     31:             return f"{n:.1f} {unit}"
+  │     32:         n /= 1024
+  │     33:     return f"{n:.1f} GiB/s"
+  │     34:
+  │     35:
+  │     36: def uptime_str(seconds: float | None) -> str:
+  │     37:     if seconds is None:
+  │     38:         return "—"
+  │     39:     td = timedelta(seconds=int(seconds))
+  │     40:     days, rem = divmod(td.seconds, 86400)
+  │     41:     hours, rem = divmod(rem, 3600)
+  │     42:     minutes = rem // 60
+  │     43:     parts: list[str] = []
+  │     44:     if days:
+  │     45:         parts.append(f"{days}d")
+  │     46:     if days or hours:
+  │     47:         parts.append(f"{hours}h")
+  │     48:     parts.append(f"{minutes}m")
+  │     49:     return " ".join(parts)
+  │     50:
+  │     51:
+  │     52: def pct(value: float | None) -> str:
+  │     53:     if value is None:
+  │     54:         return "—"
+  │     55:     return f"{value:.0f}%"
+  │     56:
+  │     57:
+  │     58: env = Environment(
+  │     59:     loader=FileSystemLoader(BASE / "templates"),
+  │     60:     autoescape=select_autoescape(("html", "j2")),
+  │     61: )
+  │     62: env.filters["humanize"] = humanize
+  │     63: env.filters["rate"] = rate
+  │     64: env.filters["uptime"] = uptime_str
+  │     65: env.filters["pct"]
+  │     … [162 more chars]
+  │
+  │ tokens 27 in 120 out 12687 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:23:49 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Now I understand the structure. Let me also check how the main page loads the plugins tab, and
+  │ look at index.html to understand the tab structure and how other tabs handle static/dynamic
+  │ separation (e.g., services might have a static list + dynamic details). Let me read index.html
+  │ and see how the plugins panel is initially embedded (it's probably loaded via hx-get to
+  │ /api/plugins on tab switch).
+  │
+  │ Also, let me check how the other templates handle static/dynamic splits, for example
+  │ service_detail.html. And check the hx-* attributes in index.html.
+  │
+  │ read /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/index.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <!doctype html>
+  │     2: <html lang="en">
+  │     3: <head>
+  │     4: <meta charset="utf-8">
+  │     5: <meta name="viewport" content="width=device-width, initial-scale=1">
+  │     6: <title>{{ hostname }}</title>
+  │     7: <link rel="stylesheet" href="/static/css/style.css">
+  │     8: <script src="/static/vendor/htmx.min.js"></script>
+  │     9: <script src="/static/vendor/chart.umd.min.js"></script>
+  │     10: </head>
+  │     11: <body>
+  │     12: <header class="topbar">
+  │     13:   <h1>{{ hostname }}</h1>
+  │     14:   <nav id="tabs">
+  │     15:     <button class="tab-btn active" data-tab="overview">Overview</button>
+  │     16:     <button class="tab-btn" data-tab="disks">Disks</button>
+  │     17:     <button class="tab-btn" data-tab="processes">Processes</button>
+  │     18:     <button class="tab-btn" data-tab="journal">Journal</button>
+  │     19:     <button class="tab-btn" data-tab="services">Services</button>
+  │     20:     <button class="tab-btn" data-tab="plugins">Plugins</button>
+  │     21:   </nav>
+  │     22: </header>
+  │     23: <main>
+  │     24:   <section id="tab-overview" class="tab">
+  │     25:     <div id="overview" class="panel" hx-get="/api/overview" hx-trigger="load, every 2s"
+  │     hx-swap="outerHTML"></div>
+  │     26:     <div class="charts-grid">
+  │     27:       <div class="chart-card"><h3>CPU / GPU %</h3><canvas id="chart-cpu"></canvas></div>
+  │     28:       <div class="chart-card"><h3>Memory / VRAM %</h3><canvas
+  │     id="chart-mem"></canvas></div>
+  │     29:       <div class="chart-card"><h3>Disk I/O</h3><canvas id="chart-io"></canvas></div>
+  │     30:     </div>
+  │     31:   </section>
+  │     32:
+  │     33:   <section id="tab-disks" class="tab hidden">
+  │     34:     <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="load, every 2s"
+  │     hx-swap="outerHTML"></div>
+  │     35:   </section>
+  │     36:
+  │     37:   <section id="tab-processes" class="tab hidden">
+  │     38:     <form id="proc-controls" class="inline-form" hx-get="/api/processes"
+  │     hx-target="#processes-body" hx-swap="outerHTML">
+  │     39:       <input id="proc-q" name="q" placeholder="filter name / pid">
+  │     40:       <select name="sort" id="proc-sort">
+  │     41:
+  │     … [3024 more chars]
+  │
+  │ tokens 1977 in 149 out 12834 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:23:56 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Now I have the full picture:
+  │
+  │ 1. `index.html`: the plugins tab initially fetches `/api/plugins` on load (`hx-trigger="load"`).
+  │ That response (from `templates/plugins.html`) renders, for each plugin, a `.plugin-body` div
+  │ that has `hx-get="/api/plugins/{id}/fragment" hx-trigger="every 5s" hx-swap="innerHTML"`. So the
+  │ entire plugin fragment (including the `<select>` dropdown) is replaced every 5 seconds. While
+  │ the user has the dropdown open, the innerHTML swap kills it.
+  │
+  │ 2. The llamacpp fragment contains:
+  │    - Static-ish UI chrome: health line (changes with health), the "Loaded models" section
+  │    (dynamic), the "Available models" section with the `<select>` + load button (dynamic
+  │    options), the actions row with rescan button (static).
+  │
+  │ Goal: split the fragment into a static part (chrome: headings, buttons, container with the
+  │ select) and a dynamic part (only the data-driven bits: health line, model list, select options)
+  │ that auto-refreshes.
+  │
+  │ Design options:
+  │
+  │ **Option A: two endpoints + nested htmx polling**
+  │ - Add a new `Plugin` method/field, e.g. `body_fn` that returns the static skeleton (no polling),
+  │ and keep `fragment` for the dynamic content.
+  │ - The plugin card in `plugins.html` renders the static skeleton once (via a new endpoint
+  │ `/api/plugins/{pid}/skeleton` or embedded on index). Inside the skeleton there's a dynamic
+  │ container div with `hx-get="/api/plugins/{pid}/fragment" hx-trigger="every 5s"
+  │ hx-swap="innerHTML"`, which only replaces the dynamic content.
+  │ - Problem: the select itself contains dynamic options (available models). If the `<select>`
+  │ lives in the static part, we can't update its options without replacing the select (which kills
+  │ the open dropdown). htmx can't easily replace just the `<option>` elements of a `<select>` —
+  │ `hx-swap` works on the whole element.
+  │
+  │ Hmm. So the dropdown is the tricky part: the options change when the model set changes
+  │ (load/unload/rescan). If the dropdown is in the dynamic part, we still hit the problem: the
+  │ fragment reloads while
+  │ … [31027 more chars]
+  │
+  │ read /home/mac/Code/dashboard/static/js/app.js                                       ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/static/js/app.js"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/static/js/app.js</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: (function () {
+  │     2:   "use strict";
+  │     3:
+  │     4:   // ---------- tabs ----------
+  │     5:   const tabBtns = document.querySelectorAll(".tab-btn");
+  │     6:   const sections = document.querySelectorAll(".tab");
+  │     7:
+  │     8:   function showTab(name) {
+  │     9:     tabBtns.forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
+  │     10:     sections.forEach((s) => s.classList.toggle("hidden", s.id !== "tab-" + name));
+  │     11:     try {
+  │     12:       localStorage.setItem("dash.tab", name);
+  │     13:     } catch (e) {}
+  │     14:   }
+  │     15:   tabBtns.forEach((b) => b.addEventListener("click", () => showTab(b.dataset.tab)));
+  │     16:   try {
+  │     17:     const saved = localStorage.getItem("dash.tab");
+  │     18:     if (saved && document.getElementById("tab-" + saved)) showTab(saved);
+  │     19:   } catch (e) {}
+  │     20:
+  │     21:   // ---------- helpers ----------
+  │     22:   function fmtBytes(n, digits) {
+  │     23:     if (n == null || isNaN(n)) return "—";
+  │     24:     if (digits == null) digits = 1;
+  │     25:     const u = ["B", "KiB", "MiB", "GiB", "TiB"];
+  │     26:     let i = 0;
+  │     27:     while (Math.abs(n) >= 1024 && i < u.length - 1) {
+  │     28:       n /= 1024;
+  │     29:       i++;
+  │     30:     }
+  │     31:     return n.toFixed(digits) + " " + u[i];
+  │     32:   }
+  │     33:
+  │     34:   function fmtTime(ts) {
+  │     35:     const d = new Date(ts * 1000);
+  │     36:     return d.toLocaleTimeString([], { hour12: false });
+  │     37:   }
+  │     38:
+  │     39:   // ---------- charts ----------
+  │     40:   const charts = {};
+  │     41:
+  │     42:   function baseOpts(extra) {
+  │     43:     const o = {
+  │     44:       animation: false,
+  │     45:       responsive: true,
+  │     46:       maintainAspectRatio: false,
+  │     47:       interaction: { mode: "index", intersect: false },
+  │     48:       plugins: { legend: { display: false } },
+  │     49:       scales: {
+  │     50:         x: { ticks: { maxTicksLimit: 7, maxRotation: 0, color: "#7d8a9c" }, grid: {
+  │     display: false } },
+  │     51:         y: { beginAtZero: true, ticks: { color: "#7d8a9c" }, grid: { color:
+  │     "rgba(42,51,66,.5)" } },
+  │     52:       },
+  │     53:     };
+  │     54:     if (extra) Object.assign(o.scal
+  │     … [5741 more chars]
+  │ bash grep -o "htmx v[0-9.]*" static/vendor/htmx.min.js | head -1; grep -o "versio…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "grep -o \"htmx v[0-9.]*\" static/vendor/htmx.min.js | head -1; grep -o
+  │       \"version:\\\"[0-9.]*\\\"\" static/vendor/htmx.min.js | head -3; ls static/vendor/"
+  │     }
+  │   out
+  │     version:"1.9.12"
+  │     chart.umd.min.js
+  │     htmx.min.js
+  │
+  │ tokens 1735 in 8315 out 14961 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:27:39 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ htmx 1.9.12. In htmx 1.9, `hx-target` does not support multiple comma-separated targets (that's
+  │ htmx 2.0 and later). So a single response cannot target two different regions.
+  │
+  │ So my "actions swap the entire .llama / .plugin-body" approach is the correct one for htmx 1.9:
+  │ actions target `closest .plugin-body` (as currently) and return the complete skeleton (including
+  │ the pre-filled state + options). The buttons are inside the skeleton and already target `closest
+  │ .plugin-body`, so this works.
+  │
+  │ Now, one problem: when the action swaps the content of .plugin-body, the inner elements with
+  │ `hx-trigger="every 5s"` and `hx-trigger="every 30s"` get re-processed and the timers restart —
+  │ no problem.
+  │
+  │ Another subtle point: does the htmx `every` trigger start counting from when the element is
+  │ processed, and is the first tick after N seconds? Yes.
+  │
+  │ Now, the "unreachable" case with a static control row: if the server is unreachable, the
+  │ skeleton renders the control row (select with no options + load button + rescan). The state div
+  │ displays an alert. Options:
+  │ 1. Don't render the control row when unreachable (skeleton knows the state at render time; the
+  │ skeleton is rendered on the index + on actions with the latest status). Since the skeleton is
+  │ re-rendered server-side on every action and on tab load, the `reachable` context variable works:
+  │ `{% if reachable %}...controls...{% endif %}`. If the server goes down after load, the controls
+  │ remain visible until the next action/tab visit — acceptable? The 5s state poll displays
+  │ "unreachable" and the rescan button does nothing but that's harmless. Hmm, a bit stale but OK.
+  │ 2. Better: keep the controls in the skeleton only when reachable (server-side conditional), same
+  │ as now (the current template has `{% else %}` unreachable → only the alert). Same semantics as
+  │ today, just that when reachable, the controls live outside the 5s swap.
+  │
+  │ So the skeleton template:
+  │
+  │ ```html
+  │ <div class="llama">
+  │   <div id="llama-state" hx-get="/api/plugins/llamacpp/st
+  │ … [30397 more chars]
+  │
+  │ I've reviewed the plugins architecture. Current flow:
+  │
+  │ - `templates/index.html:96` — Plugins tab loads `/api/plugins` once.
+  │ - `templates/plugins.html:7` — each plugin's `.plugin-body` does
+  │ `hx-get="/api/plugins/{id}/fragment"` `every 5s`, swapping the **entire** fragment (health line,
+  │ model lists, `<select>`, buttons) — so an open dropdown gets destroyed by the swap.
+  │ - `app/plugins/llamacpp.py` — `_fragment()` renders everything from `gather_status()`;
+  │ load/unload/rescan POSTs also swap the whole fragment into `.plugin-body`.
+  │ - htmx is **1.9.12** (no multiple `hx-target` support, no pause API for `every` triggers).
+  │
+  │ **Proposed split** (per-plugin, framework-level):
+  │
+  │ 1. `app/plugins/base.py` — add optional `skeleton_fn` + `skeleton()` to `Plugin`. Skeleton =
+  │ static shell rendered once; it contains the polling container(s).
+  │ 2. `app/routers/plugins.py` — index route renders `await p.skeleton()` for plugins that have
+  │ one; plugins without a skeleton keep today's behavior (whole fragment polled) as fallback.
+  │ 3. `app/plugins/llamacpp.py` + templates — split `llamacpp.html` into:
+  │    - `llamacpp_skeleton.html` — static: `.llama` wrapper, `<h4>Available models</h4>`, rescan
+  │    button; two dynamic slots:
+  │      - `#llama-state` → `hx-get …/state, every 5s` (health line, notices, loaded-models list w/
+  │      unload buttons)
+  │      - `#llama-avail` → refreshes **every 30s** (the `<select>` + load button, or "no unloaded
+  │      models" hint)
+  │    - `llamacpp_state.html` / `llamacpp_options.html` — the two dynamic fragments (also used to
+  │    pre-fill the slots at index time via Jinja `include`, inheriting context).
+  │    - New endpoints `GET /state`, `GET /options`; load/unload/rescan return the **full skeleton**
+  │    (re-targeting `closest .plugin-body` as today), so actions update both regions atomically.
+  │ 4. `static/js/app.js` — small guard: a 1s interval triggers the options refresh via a custom
+  │ htmx event, **skipped while the select is focused** — this removes the last collision (options
+  │ swap resetting an in-progress selection). Pure-htmx `every 30s` alone would still occasionally
+  │ clobber the dropdown.
+  │
+  │ llama-server load stays identical to today (one `/health`+`/models` fetch per 5s state poll;
+  │ options adds one per 30s).
+  │
+  │ Two quick decisions before I finalize:
+  │
+  │ question Asked 2 questions                                                           ok   236.4s
+  │   in
+  │     {
+  │       "questions": [
+  │         {
+  │           "question": "The available-models dropdown refreshes less often than the 5s status
+  │           poll. Which interval is fine?",
+  │           "header": "Options refresh",
+  │           "options": [
+  │             {
+  │               "label": "30s (Recommended)",
+  │               "description": "Rarely stale; model auto-sleep/load changes show up within half a
+  │               minute, instantly after any load/unload/rescan action."
+  │             },
+  │             {
+  │               "label": "10s",
+  │               "description": "Closer to today's freshness, more llama-server calls."
+  │             },
+  │             {
+  │               "label": "60s",
+  │               "description": "Cheapest; list can be a minute stale between actions."
+  │             }
+  │           ]
+  │         },
+  │         {
+  │           "question": "Add the small app.js guard that pauses the dropdown's options refresh
+  │           while the select is focused/open (eliminates the last possible clobber during
+  │           selection)?",
+  │           "header": "JS guard",
+  │           "options": [
+  │             {
+  │               "label": "Yes (Recommended)",
+  │               "description": "~12 lines in app.js; options swap is skipped while the user is
+  │               choosing."
+  │             },
+  │             {
+  │               "label": "No",
+  │               "description": "Pure htmx polling; a refresh while the dropdown is open is still
+  │               possible (rare at 30s)."
+  │             }
+  │           ]
+  │         }
+  │       ]
+  │     }
+  │   out User has answered your questions: "The available-models dropdown refreshes less often than
+  │   the 5s status poll. Which interval is fine?"="The llama plugin already has a rescan models
+  │   button so no automatic reloading is needed (if the button works)", "Add the small app.js guard
+  │   that pauses the dropdown's options refresh while the select is focused/open (eliminates the
+  │   last possible clobber during selection)?"="See previous question, no automated reload of the
+  │   dropdown is needed as it already has a rescan button". You can now continue with the user's
+  │   answers in mind.
+  │
+  │ tokens 11059 in 9079 out 16692 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:35:57 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ User's statement: No automatic reloading of the dropdown is needed — the rescan button handles
+  │ it. In other words:
+  │
+  │ - `#llama-avail` (the select + load button) is completely **static**: rendered once in the
+  │ skeleton, not auto-updated. The options are updated only by the rescan action (which re-renders
+  │ the skeleton) and by load/unload actions (which also re-render the skeleton).
+  │ - Therefore: no 30-second polling, no JS guard needed. Even simpler.
+  │
+  │ This also means: the model list in the dropdown will become stale if the llama-server
+  │ auto-unloads a model (sleep) — but the user says rescan handles that, and that's fine (the user
+  │ has explicitly chosen this).
+  │
+  │ So the final design:
+  │
+  │ **Skeleton (static, rendered once per tab load / per action):**
+  │ ```html
+  │ <div class="llama">
+  │   <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s"
+  │   hx-swap="innerHTML">
+  │     {% include "plugins/llamacpp_state.html" %}
+  │   </div>
+  │   {% if reachable %}
+  │   <h4>Available models</h4>
+  │   <div class="llama-load">
+  │     <select id="llama-model-pick" name="model">
+  │       {% for m in available %}<option ...>{% endfor %}
+  │     </select>
+  │     <button class="btn" hx-post="/api/plugins/llamacpp/load" hx-include="#llama-model-pick"
+  │     hx-target="closest .plugin-body" hx-swap="innerHTML">load</button>
+  │   </div>
+  │   (or, if there are none, a muted "no unloaded models" line)
+  │   <div class="actions"><button rescan ...></button></div>
+  │   {% endif %}
+  │ </div>
+  │ ```
+  │
+  │ **State (dynamic, 5 seconds):** health line, notice/alert, h4 Loaded models + list.
+  │
+  │ **Endpoints:**
+  │ - `GET /api/plugins/llamacpp/state` — dynamic fragment (5-second polling target)
+  │ - `GET /api/plugins/llamacpp/fragment` — keep for compatibility? The generic
+  │ `/api/plugins/{pid}/fragment` route uses `plugin.fragment()`. In the case of skeleton_fn
+  │ plugins, is the generic fragment endpoint still needed? The fallback path uses it. For llamacpp,
+  │ fragment() can keep returning the state fragment (so the generic endpoint keeps working). Keep
+  │ `fragment_fn=_sta
+  │ … [2392 more chars]
+  │
+  │ Simpler then — the dropdown becomes fully static, refreshed only by the rescan/load/unload
+  │ actions. Final plan:
+  │
+  │ ## Plan
+  │
+  │ **1. `app/plugins/base.py`** — add optional `skeleton_fn` (+ `skeleton()` method) to `Plugin`.
+  │ Skeleton = static shell, rendered once; it embeds the polling slot. `fragment_fn` becomes the
+  │ dynamic (polled) part.
+  │
+  │ **2. `app/routers/plugins.py`** — `plugins_index` builds each card body server-side:
+  │ - plugin has `skeleton_fn` → `body = await p.skeleton()` (skeleton contains the polling slot,
+  │ pre-filled)
+  │ - otherwise → legacy behavior: `<div hx-get="/api/plugins/{id}/fragment" hx-trigger="every
+  │ {poll}s" hx-swap="innerHTML">` wrapping `await p.fragment()` (keeps the plugin system generic)
+  │ - exceptions → alert div, as today. `templates/plugins.html` just does `{{ item.body | safe }}`.
+  │
+  │ **3. `app/plugins/llamacpp.py`** —
+  │ - extract list-building into a helper; `_fragment` → `_state` (health line, notices,
+  │ loaded-models list) rendered from new `llamacpp_state.html`
+  │ - new `_skeleton(message, error)` → renders `llamacpp_skeleton.html` with the same status
+  │ context
+  │ - new endpoint `GET /api/plugins/llamacpp/state` (the 5s poll target); `fragment_fn=_state`
+  │ keeps the generic `/fragment` route working
+  │ - load/unload/rescan POSTs return `await _skeleton(message, error)` instead of the fragment
+  │
+  │ **4. Templates** — replace `templates/plugins/llamacpp.html` with:
+  │ - `llamacpp_skeleton.html`: static shell — `<div class="llama">` containing `#llama-state`
+  │ (`hx-get …/state`, `hx-trigger="every 5s"`, `hx-swap="innerHTML"`, pre-filled via `{% include
+  │ "plugins/llamacpp_state.html" %}` which inherits context), then when reachable: the
+  │ `<h4>Available models</h4>` + **static** `<select>` + load button (or the "no unloaded models"
+  │ hint) + rescan button. All action buttons keep `hx-target="closest .plugin-body"`, so their
+  │ skeleton response re-renders the whole card (including a fresh dropdown).
+  │ - `llamacpp_state.html`: the 5s dynamic part (unreachable alert / health line / notices /
+  │ loaded-models list with unload buttons).
+  │
+  │ **5. No changes** to `app.js`, `index.html`, CSS, or llama-server call volume (one
+  │ `/health`+`/models` per 5s state poll — same as today; no dropdown polling at all).
+  │
+  │ **Result:** while picking from the dropdown, only the loaded-models/health area swaps every 5s;
+  │ the `<select>` node is never touched until the user clicks load/unload/rescan.
+  │
+  │ **Verify:** `uv run python -m compileall -q app`, restart server, `curl` `/api/plugins`
+  │ (skeleton + pre-filled state present), `/api/plugins/llamacpp/state`, POST `/rescan`; `grep -c
+  │ Traceback /tmp/dash.log`; basedpyright.
+  │
+  │ Want me to proceed with implementation?
+  │
+  │ tokens 9216 in 1822 out 27747 cached 0 written $0.0000 stop
+
+
+  │ 2026-08-30 19:37:55 • user
+  │
+  │ we don't need the legacy behaviour as the only plugin is the llama one we're rewriting anyways.
+
+
+  │ 2026-08-30 19:37:55 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ User's statement: the legacy behavior (fallback for plugins without a skeleton) is unnecessary —
+  │ since the only plugin is llamacpp, and it will be rewritten to have a skeleton. In other words,
+  │ simplify: no fallback path needed. But how far do we go? Options:
+  │
+  │ 1. Keep the `Plugin` dataclass generic, with both `fragment_fn` and `skeleton_fn` optional, but
+  │ have the router just call `p.skeleton()` and have no fallback branch (llamacpp provides both).
+  │ 2. Go further: make `skeleton_fn` required / restructure the dataclass? The user said "legacy
+  │ behavior is unnecessary" — meaning, drop the fallback wrapping in the router. We can keep the
+  │ dataclass as is (both optional), and the router can just call `p.skeleton()`, raising an
+  │ exception if None (caught by the per-plugin try → alert div, as currently). This is clean: a
+  │ plugin without a skeleton_fn just shows "plugin error: ...". Hmm, that would display an error
+  │ for plugins that only have a fragment — but there's only one plugin, so no problem.
+  │
+  │ Actually, the simplest interpretation: the router's index always renders the skeleton. No legacy
+  │ branch. The generic `/api/plugins/{pid}/fragment` endpoint — keep or remove? It's part of the
+  │ old full-fragment design. Now that llamacpp has its own `/state` endpoint and the skeleton, is
+  │ the generic fragment endpoint needed? The plugins.py router has
+  │ `@router.get("/{pid}/fragment")`. If no plugin uses it anymore (llamacpp polls its own
+  │ `/state`), it could be removed. But `fragment()`/`fragment_fn` on Plugin — llamacpp still uses
+  │ `_state` as its "fragment" (dynamic part). Should we keep `fragment_fn` on the dataclass? The
+  │ skeleton template doesn't call it; the router's index calls skeleton(). The only user of the
+  │ generic `/fragment` route was the legacy polling div. If we remove the legacy behavior, the
+  │ generic `/fragment` endpoint becomes dead code → remove. And `Plugin.fragment_fn` / `fragment()`
+  │ also become dead code → remove, or keep?
+  │
+  │ The cleanest is: restructure `Plugin` to have `ske
+  │ … [2368 more chars]
+  │
+  │ grep fragment|poll_seconds|skeleton                                                  ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "fragment|poll_seconds|skeleton",
+  │       "include": "*.{py,html,js,md}"
+  │     }
+  │   out
+  │     Found 28 matches
+  │     /home/mac/Code/dashboard/AGENTS.md:
+  │       Line 8: managed with `uv`) backend serving htmx + Chart.js HTML fragments to one
+  │
+  │       Line 49:   HTML fragment; templates live in `templates/` and self-poll via
+  │
+  │
+  │     /home/mac/Code/dashboard/README.md:
+  │       Line 131: templates/            # htmx fragments
+  │
+  │       Line 137: instance (id, title, poll interval, fragment function) and register it in
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:
+  │       Line 90: async def _fragment(message: str = "", error: str = "") -> str:
+  │
+  │       Line 102: @router.get("/fragment")
+  │
+  │       Line 103: async def fragment():
+  │
+  │       Line 104:     return HTMLResponse(await _fragment())
+  │
+  │       Line 111:         await _fragment(
+  │
+  │       Line 122:         await _fragment(
+  │
+  │       Line 141:     return HTMLResponse(await _fragment(message=msg, error=err))
+  │
+  │       Line 148:     poll_seconds=5,
+  │
+  │       Line 149:     fragment_fn=_fragment,
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins.html:
+  │       Line 7:     <div class="plugin-body" hx-get="/api/plugins/{{ item.p.id }}/fragment"
+  │       hx-trigger="every {{ item.p.poll_seconds }}s" hx-swap="innerHTML">{{ item.frag | safe
+  │       }}</div>
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/service_detail.html:
+  │       Line 10:     <div><span class="muted">fragment:</span> <span class="mono">{{
+  │       props.get("FragmentPath", "") }}</span></div>
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/base.py:
+  │       Line 10:     poll_seconds: int = 5
+  │
+  │       Line 11:     fragment_fn: Callable[[], Awaitable[str]] | None = field(default=None)
+  │
+  │       Line 13:     async def fragment(self) -> str:
+  │
+  │       Line 14:         if self.fragment_fn is None:
+  │
+  │       Line 16:         return await self.fragment_fn()
+  │
+  │
+  │     /home/mac/Code/dashboard/app/routers/services.py:
+  │       Line 45: async def _list_fragment(q: str, sort: str = "name", order: str = "asc", error:
+  │       str | None = None) -> str:
+  │
+  │       Line 75:     return HTMLResponse(await _list_fragment(q, sort, order))
+  │
+  │       Line 110:     return HTMLResponse(await _list_fragment(q, sort, order, error=error))
+  │
+  │
+  │     /home/mac/Code/dashboard/app/routers/plugins.py:
+  │       Line
+  │     … [2262 more chars]
+  │
+  │ tokens 30103 in 1112 out 8713 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:39:19 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Confirmed the scope of impact. The `fragment`/`poll_seconds` concept is only used in the plugin
+  │ mechanism (plus there's a mention in the README, and a similar but unrelated `_list_fragment` in
+  │ services.py — not touching that).
+  │
+  │ User says: no legacy behavior needed. Therefore:
+  │
+  │ - `Plugin`: replace `fragment_fn`/`fragment()`/`poll_seconds` with `skeleton_fn`/`skeleton()`.
+  │ Should `poll_seconds` be kept? Nothing else reads it (only the legacy wrapper in plugins.html
+  │ used it, but that's being removed). The skeleton template hardcodes the URL + interval (it's a
+  │ per-plugin template anyway). Remove `poll_seconds` too — cleaner. Hmm, wait: is there value in
+  │ keeping `poll_seconds` as metadata? The skeleton's state slot hardcodes `every 5s` in
+  │ llamacpp_skeleton.html. Removing it keeps the dataclass minimal: id, title, description,
+  │ skeleton_fn. Alright.
+  │
+  │ - `app/routers/plugins.py`: index builds `body = await p.skeleton()` with per-plugin try/except
+  │ → alert. Remove the `/{pid}/fragment` endpoint.
+  │
+  │ - `templates/plugins.html`: `<div class="plugin-body">{{ item.body | safe }}</div>`.
+  │
+  │ - `llamacpp.py`:
+  │   - `_lists(status)` helper (sort loaded/available)
+  │   - `_state(message="", error="")` → `render("plugins/llamacpp_state.html", **status)`
+  │   - `_skeleton(message="", error="")` → `render("plugins/llamacpp_skeleton.html", **status)`
+  │   - `GET /state` endpoint → `_state()`
+  │   - POST load/unload/rescan → `_skeleton(message, error)`
+  │   - `plugin = Plugin(id="llamacpp", title=..., description=..., skeleton_fn=_skeleton)`
+  │   - Remove the `GET /fragment` endpoint (line 102–104).
+  │
+  │ - Templates:
+  │   - Delete `templates/plugins/llamacpp.html`
+  │   - New `templates/plugins/llamacpp_state.html`: the current fragment contents minus the
+  │   select/rescan rows (health, unreachable branch, notices, h4 + list of loaded models).
+  │   - New `templates/plugins/llamacpp_skeleton.html`: `.llama` wrapper + `#llama-state` slot
+  │   (hx-get `/api/plugins/llamacpp/state`, `hx-trigger="every 5s"`, `hx-swap="innerHTML"`,
+  │   pre-filled v
+  │ … [2375 more chars]
+  │
+  │ Good — that simplifies it further. The generic `/{pid}/fragment` endpoint and
+  │ `fragment_fn`/`poll_seconds` become dead code and get removed. Revised final plan:
+  │
+  │ ## Final plan
+  │
+  │ **`app/plugins/base.py`** — `Plugin` becomes `id`, `title`, `description`, `skeleton_fn` (+
+  │ `skeleton()` method). Remove `fragment_fn`, `fragment()`, `poll_seconds`.
+  │
+  │ **`app/routers/plugins.py`** — index: `body = await p.skeleton()` per plugin, try/except → alert
+  │ div (as today). Delete the `GET /{pid}/fragment` route.
+  │
+  │ **`templates/plugins.html`** — `<div class="plugin-body">{{ item.body | safe }}</div>`.
+  │
+  │ **`app/plugins/llamacpp.py`**
+  │ - helper building the sorted `loaded`/`available` lists from `gather_status()`
+  │ - `_state(message="", error="")` → `render("plugins/llamacpp_state.html", **status)`
+  │ - `_skeleton(message="", error="")` → `render("plugins/llamacpp_skeleton.html", **status)`
+  │ - new `GET /state` endpoint (the 5s poll target)
+  │ - load/unload/rescan POSTs return `await _skeleton(message, error)`
+  │ - delete `GET /fragment`; `Plugin(..., skeleton_fn=_skeleton)`
+  │
+  │ **Templates** — delete `templates/plugins/llamacpp.html`, add:
+  │ - `llamacpp_skeleton.html`: static `.llama` shell — `#llama-state` slot
+  │ (`hx-get="/api/plugins/llamacpp/state"`, `hx-trigger="every 5s"`, `hx-swap="innerHTML"`,
+  │ pre-filled via `{% include "plugins/llamacpp_state.html" %}`, which inherits the render
+  │ context); when reachable: `<h4>Available models</h4>` + **static** `<select>` + load button (or
+  │ the "no unloaded models" hint) + rescan button. All action buttons keep `hx-target="closest
+  │ .plugin-body"` so their skeleton response re-renders the whole card with a fresh dropdown.
+  │ - `llamacpp_state.html`: the 5s dynamic part — unreachable alert / health line / notices /
+  │ loaded-models list with unload buttons.
+  │
+  │ **`README.md`** — update the plugins section line that describes the old `(id, title, poll
+  │ interval, fragment function)` fields.
+  │
+  │ No JS, CSS, or index.html changes; llama-server call volume unchanged (one `/health`+`/models`
+  │ per 5s). The `<select>` is now only ever replaced by an explicit user action. One accepted
+  │ tradeoff: if the llama-server dies while the tab is open, the (now static) dropdown/rescan stay
+  │ visible until the next action or tab reload, while the 5s state area shows the unreachable
+  │ alert.
+  │
+  │ Proceed with implementation?
+  │
+  │ tokens 1230 in 1716 out 39929 cached 0 written $0.0000 stop
+
+
+  │ 2026-08-30 19:40:56 • user
+  │
+  │ ok proceed
+
+
+  │ 2026-08-30 19:40:56 • assistant • Qwen3.8-27B-Think
+  │
+  │ Alright, let's implement. Steps:
+  │
+  │ 1. Rewrite `app/plugins/base.py`.
+  │ 2. Rewrite `app/routers/plugins.py`.
+  │ 3. Rewrite `templates/plugins.html`.
+  │ 4. Update `app/plugins/llamacpp.py`.
+  │ 5. Delete `templates/plugins/llamacpp.html`; add `llamacpp_skeleton.html` and
+  │ `llamacpp_state.html`.
+  │ 6. Update README.md.
+  │ 7. Verify: compileall, lint (basedpyright per AGENTS.md — let me check how it's configured:
+  │ "basedpyright is configured as linter". Check pyproject.toml for the lint config/command).
+  │ 8. Restart the server and curl the endpoints.
+  │
+  │ Should I set up a todo list? This is a multi-step task (7 files). Yeah, let's use todowrite.
+  │
+  │ Let me check pyproject.toml for the lint config.
+  │
+  │ todowrite 6 todos                                                                    ok     0.0s
+  │   in
+  │     {
+  │       "todos": [
+  │         {
+  │           "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │           "status": "in_progress",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Split llamacpp templates into skeleton + state",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update llamacpp.py endpoints and Plugin instance",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update templates/plugins.html and README",
+  │           "status": "pending",
+  │           "priority": "medium"
+  │         },
+  │         {
+  │           "content": "Verify: compileall, lint, restart, curl endpoints",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         }
+  │       ]
+  │     }
+  │   out
+  │     [
+  │       {
+  │         "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │         "status": "in_progress",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Split llamacpp templates into skeleton + state",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update llamacpp.py endpoints and Plugin instance",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update templates/plugins.html and README",
+  │         "status": "pending",
+  │         "priority": "medium"
+  │       },
+  │       {
+  │         "content": "Verify: compileall, lint, restart, curl endpoints",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       }
+  │     ]
+  │ read /home/mac/Code/dashboard/pyproject.toml                                         ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/pyproject.toml"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/pyproject.toml</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: [project]
+  │     2: name = "dashboard"
+  │     3: version = "0.1.0"
+  │     4: description = "Computer dashboard and combined task manager (FastAPI + htmx)"
+  │     5: license = "Unlicense"
+  │     6: license-files = ["LICENSE"]
+  │     7: requires-python = ">=3.12"
+  │     8: dependencies = [
+  │     9:     "fastapi>=0.141.1",
+  │     10:     "httpx>=0.28.1",
+  │     11:     "jinja2>=3.1.6",
+  │     12:     "psutil>=7.2.2",
+  │     13:     "pydantic-settings>=2.15.0",
+  │     14:     "python-multipart>=0.0.32",
+  │     15:     "uvicorn[standard]>=0.52.4",
+  │     16: ]
+  │     17:
+  │     18: [tool.uv]
+  │     19: package = false
+  │     20:
+  │     21: [tool.basedpyright]
+  │     22: reportExplicitAny = false
+  │     23: reportAny = false
+  │
+  │     (End of file - total 23 lines)
+  │     </content>
+  │
+  │ tokens 33758 in 417 out 8906 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:42:05 • assistant • Qwen3.8-27B-Think
+  │
+  │ basedpyright is the linter. I'll check whether it's installed (uvx basedpyright, or within the
+  │ environment). I'll verify with `uv run basedpyright --version` or `uvx`. I'll handle that at
+  │ verification time.
+  │
+  │ Alright, now let me write the file.
+  │
+  │ 1. base.py:
+  │
+  │ write /home/mac/Code/dashboard/app/plugins/base.py                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/base.py",
+  │       "content": "from collections.abc import Awaitable, Callable\nfrom dataclasses import
+  │       dataclass, field\n\n\n@dataclass\nclass Plugin:\n    id: str\n    title: str\n
+  │       description: str = \"\"\n    skeleton_fn: Callable[[], Awaitable[str]] | None =
+  │       field(default=None)\n\n    async def skeleton(self) -> str:\n        if self.skeleton_fn
+  │       is None:\n            raise NotImplementedError\n        return await
+  │       self.skeleton_fn()\n"
+  │     }
+  │   out Wrote file successfully.
+  │
+  │ tokens 559 in 212 out 43080 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) e54767d1
+
+
+  │ 2026-08-30 19:42:11 • assistant • Qwen3.8-27B-Think
+  │
+  │ 2. Router.
+  │
+  │ write /home/mac/Code/dashboard/app/routers/plugins.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/routers/plugins.py",
+  │       "content": "from fastapi import APIRouter\nfrom fastapi.responses import
+  │       HTMLResponse\n\nfrom app.plugins import PLUGINS, Plugin\nfrom app.render import
+  │       render\n\nrouter = APIRouter(prefix=\"/api/plugins\",
+  │       tags=[\"plugins\"])\n\n\n@router.get(\"\")\nasync def plugins_index():\n    items:
+  │       list[dict[str, Plugin | str]] = []\n    for p in PLUGINS:\n        try:\n            body
+  │       = await p.skeleton()\n        except Exception as e: # noqa\n            body = f\"<div
+  │       class='alert'>plugin error: {e}</div>\"\n        items.append({\"p\": p, \"body\":
+  │       body})\n    return HTMLResponse(render(\"plugins.html\", items=items))\n"
+  │     }
+  │   out Wrote file successfully.
+  │
+  │ tokens 19 in 199 out 43852 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) b60a403a
+
+
+  │ 2026-08-30 19:42:16 • assistant • Qwen3.8-27B-Think
+  │
+  │ 3. Template.
+  │
+  │ llamacpp_state.html — extracted from the old llamacpp.html, excluding the static rows (select +
+  │ load, actions/rescan):
+  │
+  │ ```html
+  │ {% if not reachable %}
+  │ <div class="alert">Cannot reach llama-server at <span class="mono">{{ base_url }}</span>{% if
+  │ error %}: {{ error }}{% endif %}</div>
+  │ <div class="muted small">Start it in router mode: <span class="mono">llama-server --models-dir
+  │ /path/to/models</span></div>
+  │ {% else %}
+  │ <div class="llama-health">
+  │   <span class="dot {{ "dot-run" if health == "ok" else "dot-failed" }}"></span>
+  │   <span class="llama-health-text">{{ "healthy" if health == "ok" else (health or "status
+  │   unknown") }}</span>
+  │   <span class="muted small mono">{{ base_url }}</span>
+  │ </div>
+  │ {% if message %}<div class="notice">{{ message }}</div>{% endif %}
+  │ {% if error_msg %}<div class="alert">{{ error_msg }}</div>{% endif %}
+  │
+  │ <h4>Loaded models</h4>
+  │ {% if loaded %}
+  │ <div class="llama-models">
+  │   {% for m in loaded %}
+  │   <div class="llama-model">
+  │     <span class="dot {{ "dot-run" if m.state == "loaded" else ("dot-sleep" if m.state ==
+  │     "sleeping" else ("dot-failed" if m.failed else "dot-busy")) }}"></span>
+  │     <span class="mono llama-id" title="{{ m.path }}">{{ m.id }}</span>
+  │     <span class="badge badge-{{ "failed" if m.failed else m.state }}">{{ m.state }}{% if
+  │     m.failed %} (exit {{ m.exit_code }}){% endif %}</span>
+  │     {% if m.progress is not none %}<div class="bar small-bar"><div class="bar-fill"
+  │     style="width: {{ m.progress }}%"></div></div>{% endif %}
+  │     <span class="llama-model-actions">
+  │       <button class="btn" hx-post="/api/plugins/llamacpp/unload" hx-vals='{"model":"{{ m.id
+  │       }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML" hx-confirm="Unload {{ m.id
+  │       }}?">Unload</button>
+  │     </span>
+  │   </div>
+  │   {% endfor %}
+  │ </div>
+  │ {% else %}
+  │ <div class="muted small">No models loaded</div>
+  │ {% endif %}
+  │ {% endif %}
+  │ ```
+  │
+  │ Note: In the old template, the closing `{% endif %}` for the unreachable branch was at the very
+  │ end (line 50). In the state template, we need to cl
+  │ … [1069 more chars]
+  │
+  │ write /home/mac/Code/dashboard/templates/plugins/llamacpp_state.html                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_state.html",
+  │       "content": "{% if not reachable %}\n<div class=\"alert\">llama-server unreachable at <span
+  │       class=\"mono\">{{ base_url }}</span>{% if error %}: {{ error }}{% endif %}</div>\n<div
+  │       class=\"muted small\">start it in router mode: <span class=\"mono\">llama-server
+  │       --models-dir /path/to/models</span></div>\n{% else %}\n<div class=\"llama-health\">\n
+  │       <span class=\"dot {{ \"dot-run\" if health == \"ok\" else \"dot-failed\" }}\"></span>\n
+  │       <span class=\"llama-health-text\">{{ \"healthy\" if health == \"ok\" else (health or
+  │       \"status unknown\") }}</span>\n  <span class=\"muted small mono\">{{ base_url
+  │       }}</span>\n</div>\n{% if message %}<div class=\"notice\">{{ message }}</div>{% endif
+  │       %}\n{% if error_msg %}<div class=\"alert\">{{ error_msg }}</div>{% endif %}\n\n<h4>Loaded
+  │       models</h4>\n{% if loaded %}\n<div class=\"llama-models\">\n  {% for m in loaded %}\n
+  │       <div class=\"llama-model\">\n    <span class=\"dot {{ \"dot-run\" if m.state == \"loaded\"
+  │       else (\"dot-sleep\" if m.state == \"sleeping\" else (\"dot-failed\" if m.failed else
+  │       \"dot-busy\")) }}\"></span>\n    <span class=\"mono llama-id\" title=\"{{ m.path }}\">{{
+  │       m.id }}</span>\n    <span class=\"badge badge-{{ \"failed\" if m.failed else m.state
+  │       }}\">{{ m.state }}{% if m.failed %} (exit {{ m.exit_code }}){% endif %}</span>\n    {% if
+  │       m.progress is not none %}<div class=\"bar small-bar\"><div class=\"bar-fill\"
+  │       style=\"width: {{ m.progress }}%\"></div></div>{% endif %}\n    <span
+  │       class=\"llama-model-actions\">\n      <button class=\"btn\"
+  │       hx-post=\"/api/plugins/llamacpp/unload\" hx-vals='{\"model\":\"{{ m.id }}\"}'
+  │       hx-target=\"closest .plugin-body\" hx-swap=\"innerHTML\" hx-confirm=\"Unload {{ m.id
+  │       }}?\">unload</button>\n    </span>\n  </div>\n  {% endfor %}\n</div>\n{% else %}\n<div
+  │       class=\"muted small\">no models loaded</div>\n{% endif %}\n{% endif %}\n"
+  │     }
+  │   out Wrote file successfully.
+  │ write /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html              ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html",
+  │       "content": "<div class=\"llama\">\n  <div id=\"llama-state\"
+  │       hx-get=\"/api/plugins/llamacpp/state\" hx-trigger=\"every 5s\" hx-swap=\"innerHTML\">\n
+  │       {% include \"plugins/llamacpp_state.html\" %}\n  </div>\n  {% if reachable %}\n
+  │       <h4>Available models</h4>\n  {% if available %}\n  <div class=\"llama-load\">\n    <select
+  │       id=\"llama-model-pick\" name=\"model\">\n      {% for m in available %}\n      <option
+  │       value=\"{{ m.id }}\">{{ m.id }}{% if m.failed %} (failed, exit {{ m.exit_code }}){% endif
+  │       %}</option>\n      {% endfor %}\n    </select>\n    <button class=\"btn\"
+  │       hx-post=\"/api/plugins/llamacpp/load\" hx-include=\"#llama-model-pick\"
+  │       hx-target=\"closest .plugin-body\" hx-swap=\"innerHTML\">load</button>\n  </div>\n  {%
+  │       else %}\n  <div class=\"muted small\">no unloaded models (is --models-dir set on the
+  │       server?)</div>\n  {% endif %}\n\n  <div class=\"actions\">\n    <button class=\"btn\"
+  │       hx-post=\"/api/plugins/llamacpp/rescan\" hx-target=\"closest .plugin-body\"
+  │       hx-swap=\"innerHTML\">rescan models</button>\n  </div>\n  {% endif %}\n</div>\n"
+  │     }
+  │   out Wrote file successfully.
+  │ write /home/mac/Code/dashboard/templates/plugins.html                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins.html",
+  │       "content": "<div id=\"plugins\" class=\"panel\">\n  <div class=\"muted small\">plugins
+  │       load from <span class=\"mono\">app/plugins/</span> &mdash; each module exposes a <span
+  │       class=\"mono\">Plugin</span> instance</div>\n  {% for item in items %}\n  <div
+  │       class=\"plugin-card\">\n    <h3>{{ item.p.title }}</h3>\n    <p class=\"muted small\">{{
+  │       item.p.description }}</p>\n    <div class=\"plugin-body\">{{ item.body | safe }}</div>\n
+  │       </div>\n  {% else %}\n  <div class=\"muted\">no plugins registered</div>\n  {% endfor
+  │       %}\n</div>\n"
+  │     }
+  │   out Wrote file successfully.
+  │
+  │ tokens 19 in 2109 out 44071 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 3 file(s) fdb5aec6
+
+
+  │ 2026-08-30 19:43:03 • assistant • Qwen3.8-27B-Think
+  │
+  │ 5. llamacpp.py — rewrite the relevant sections:
+  │
+  │ - Remove `GET /fragment`
+  │ - `_fragment` → rename to `_state` and have it render `llamacpp_state.html`
+  │ - Add `_skeleton` that renders `llamacpp_skeleton.html`
+  │ - Actions return `_skeleton(message, error)`
+  │ - New `GET /state`
+  │ - `Plugin(..., skeleton_fn=_skeleton)`
+  │
+  │ Extract the list construction part? Currently the list is computed inside `_fragment`. Both
+  │ `_state` and `_skeleton` need it (the skeleton passes the context to the state include). So
+  │ compute it in a helper:
+  │
+  │ ```python
+  │ def _with_lists(status: dict[str, Any]) -> dict[str, Any]:
+  │     active = {m["id"] for m in status["models"] if m["state"] in ("loaded", "sleeping",
+  │     "loading")}
+  │     status["loaded"] = [m for m in status["models"] if m["id"] in active]
+  │     status["available"] = [m for m in status["models"] if m["id"] not in active]
+  │     status["loaded"].sort(key=lambda m: (m["state"] != "loaded", m["state"] != "sleeping",
+  │     m["id"]))
+  │     status["available"].sort(key=lambda m: m["id"])
+  │     return status
+  │
+  │
+  │ async def _state(message: str = "", error: str = "") -> str:
+  │     status = _with_lists(await gather_status())
+  │     status["message"] = message
+  │     status["error_msg"] = error
+  │     return render("plugins/llamacpp_state.html", **status)
+  │
+  │
+  │ async def _skeleton(message: str = "", error: str = "") -> str:
+  │     status = _with_lists(await gather_status())
+  │     status["message"] = message
+  │     status["error_msg"] = error
+  │     return render("plugins/llamacpp_skeleton.html", **status)
+  │ ```
+  │
+  │ Actually, `_skeleton` could just reuse it, but... it's a different template. I'll leave both as
+  │ they are.
+  │
+  │ Router endpoints:
+  │ ```python
+  │ @router.get("/state")
+  │ async def state():
+  │     return HTMLResponse(await _state())
+  │ ```
+  │
+  │ load/unload/rescan → `await _skeleton(message=..., error=...)`.
+  │
+  │ Plugin:
+  │ ```python
+  │ plugin = Plugin(
+  │     id="llamacpp",
+  │     title="llama.cpp",
+  │     description="Loaded model status for a llama-server in router mode, with load / unload
+  │     controls.",
+  │     skeleton_fn=_skeleton,
+  │ )
+  │ ```
+  │
+  │ Alright
+  │ … [314 more chars]
+  │
+  │ edit /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py",
+  │       "oldString": "async def _fragment(message: str = \"\", error: str = \"\") -> str:\n
+  │       status = await gather_status()\n    status[\"message\"] = message\n
+  │       status[\"error_msg\"] = error\n    active = {m[\"id\"] for m in status[\"models\"] if
+  │       m[\"state\"] in (\"loaded\", \"sleeping\", \"loading\")}\n    status[\"loaded\"] = [m for
+  │       m in status[\"models\"] if m[\"id\"] in active]\n    status[\"available\"] = [m for m in
+  │       status[\"models\"] if m[\"id\"] not in active]\n    status[\"loaded\"].sort(key=lambda m:
+  │       (m[\"state\"] != \"loaded\", m[\"state\"] != \"sleeping\", m[\"id\"]))\n
+  │       status[\"available\"].sort(key=lambda m: m[\"id\"])\n    return
+  │       render(\"plugins/llamacpp.html\", **status)\n\n\n@router.get(\"/fragment\")\nasync def
+  │       fragment():\n    return HTMLResponse(await _fragment())",
+  │       "newString": "def _with_lists(status: dict[str, Any]) -> dict[str, Any]:\n    active =
+  │       {m[\"id\"] for m in status[\"models\"] if m[\"state\"] in (\"loaded\", \"sleeping\",
+  │       \"loading\")}\n    status[\"loaded\"] = [m for m in status[\"models\"] if m[\"id\"] in
+  │       active]\n    status[\"available\"] = [m for m in status[\"models\"] if m[\"id\"] not in
+  │       active]\n    status[\"loaded\"].sort(key=lambda m: (m[\"state\"] != \"loaded\",
+  │       m[\"state\"] != \"sleeping\", m[\"id\"]))\n    status[\"available\"].sort(key=lambda m:
+  │       m[\"id\"])\n    return status\n\n\ndef _status(message: str, error: str) -> dict[str,
+  │       Any]:\n    status = _with_lists(gather_status_now())\n    status[\"message\"] = message\n
+  │       status[\"error_msg\"] = error\n    return status\n\n\nasync def _state(message: str =
+  │       \"\", error: str = \"\") -> str:\n    return render(\"plugins/llamacpp_state.html\",
+  │       **await _status(message, error))\n\n\nasync def _skeleton(message: str = \"\", error: str
+  │       = \"\") -> str:\n    return render(\"plugins/llamacpp_skeleton.html\", **await
+  │       _status(message, error))\n\n\n@router.get(\"/state\")\nasync def state():\n    return
+  │       HTMLRespon
+  │     … [21 more chars]
+  │   out Edit applied successfully.
+  │
+  │ tokens 40 in 1222 out 46199 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) 48d61129
+
+
+  │ 2026-08-30 19:43:33 • assistant • Qwen3.8-27B-Think
+  │
+  │ Wait, I wrote `gather_status_now()`, but that's wrong—it should be `await gather_status()`. Let
+  │ me fix `_status`—it needs to be async:
+  │
+  │ ```python
+  │ async def _status(message: str, error: str) -> dict[str, Any]:
+  │     status = _with_lists(await gather_status())
+  │     status["message"] = message
+  │     status["error_msg"] = error
+  │     return status
+  │ ```
+  │
+  │ edit /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py",
+  │       "oldString": "def _status(message: str, error: str) -> dict[str, Any]:\n    status =
+  │       _with_lists(gather_status_now())\n    status[\"message\"] = message\n
+  │       status[\"error_msg\"] = error\n    return status",
+  │       "newString": "async def _status(message: str, error: str) -> dict[str, Any]:\n    status =
+  │       _with_lists(await gather_status())\n    status[\"message\"] = message\n
+  │       status[\"error_msg\"] = error\n    return status"
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 18 in 255 out 47462 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) 10d62047
+
+
+  │ 2026-08-30 19:43:39 • assistant • Qwen3.8-27B-Think
+  │
+  │ Next, I'll update the 3 action endpoints that call `_fragment(` → `_skeleton(`, and also update
+  │ the Plugin instance.
+  │
+  │ edit /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py",
+  │       "oldString": "@router.post(\"/load\")\nasync def load(model: str = Form(...)):\n    ok,
+  │       err = await _action(\"/models/load\", model)\n    return HTMLResponse(\n        await
+  │       _fragment(\n            message=f\"loading {model}\" if ok else \"\",\n
+  │       error=\"\" if ok else err,\n        )\n    )\n\n\n@router.post(\"/unload\")\nasync def
+  │       unload(model: str = Form(...)):\n    ok, err = await _action(\"/models/unload\", model)\n
+  │       return HTMLResponse(\n        await _fragment(\n            message=f\"unloading {model}\"
+  │       if ok else \"\",\n            error=\"\" if ok else err,\n        )\n    )",
+  │       "newString": "@router.post(\"/load\")\nasync def load(model: str = Form(...)):\n    ok,
+  │       err = await _action(\"/models/load\", model)\n    return HTMLResponse(\n        await
+  │       _skeleton(\n            message=f\"loading {model}\" if ok else \"\",\n
+  │       error=\"\" if ok else err,\n        )\n    )\n\n\n@router.post(\"/unload\")\nasync def
+  │       unload(model: str = Form(...)):\n    ok, err = await _action(\"/models/unload\", model)\n
+  │       return HTMLResponse(\n        await _skeleton(\n            message=f\"unloading {model}\"
+  │       if ok else \"\",\n            error=\"\" if ok else err,\n        )\n    )"
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py",
+  │       "oldString": "    except httpx.HTTPError as e:\n        msg, err = \"\", f\"unreachable:
+  │       {e.__class__.__name__}\"\n    return HTMLResponse(await _fragment(message=msg,
+  │       error=err))\n\n\nplugin = Plugin(\n    id=\"llamacpp\",\n    title=\"llama.cpp\",\n
+  │       description=\"Loaded model status for a llama-server in router mode, with load / unload
+  │       controls.\",\n    poll_seconds=5,\n    fragment_fn=_fragment,\n)",
+  │       "newString": "    except httpx.HTTPError as e:\n        msg, err = \"\", f\"unreachable:
+  │       {e.__class__.__name__}\"\n    return HTMLResponse(await _skeleton(message=msg,
+  │       error=err))\n\n\nplugin = Plugin(\n    id=\"llamacpp\",\n    title=\"llama.cpp\",\n
+  │       description=\"Loaded model status for a llama-server in router mode, with load / unload
+  │       controls.\",\n    skeleton_fn=_skeleton,\n)"
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 20 in 646 out 47734 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) e7870f80
+
+
+  │ 2026-08-30 19:43:54 • assistant • Qwen3.8-27B-Think
+  │
+  │ Next, I'll delete the old llamacpp.html template, and update the plugins section of the README.
+  │ Let me check the relevant section of the README.
+  │
+  │ bash rm templates/plugins/llamacpp.html                                              ok     0.0s
+  │   in
+  │     {
+  │       "command": "rm templates/plugins/llamacpp.html"
+  │     }
+  │   out (no output)
+  │ read /home/mac/Code/dashboard/README.md                                              ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/README.md",
+  │       "offset": 120,
+  │       "limit": 30
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/README.md</path>
+  │     <type>file</type>
+  │     <content>
+  │     120: app/
+  │     121:   config.py           # pydantic-settings (DASH_* env)
+  │     122:   main.py             # app factory, lifespan sampler
+  │     123:   sampling.py         # background sampler task
+  │     124:   state.py            # in-memory ring buffers
+  │     125:   collect/            # cpu / mem / gpu / disks / procs / net collectors (psutil +
+  │     sysfs)
+  │     126:   systemd/units.py    # unit list / detail / whitelisted actions (sudo fallback)
+  │     127:   journal.py          # journalctl -o export parser + cursors
+  │     128:   render.py           # jinja env + filters
+  │     129:   routers/            # overview / disks / processes / journal / services / plugins
+  │     130:   plugins/            # base.Plugin + llamacpp plugin
+  │     131: templates/            # htmx fragments
+  │     132: static/               # css, js, vendored htmx + chart.js
+  │     133: deploy/               # dashboard.service
+  │     134: ```
+  │     135:
+  │     136: Adding a plugin: create a module in `app/plugins/` defining a `Plugin`
+  │     137: instance (id, title, poll interval, fragment function) and register it in
+  │     138: `app/plugins/__init__.py`.
+  │     139:
+  │     140: ## License
+  │     141:
+  │     142: [The Unlicense](LICENSE) — public domain dedication, no conditions.
+  │     143:
+  │     144: [uv]: https://docs.astral.sh/uv/
+  │
+  │     (End of file - total 144 lines)
+  │     </content>
+  │
+  │ tokens 29 in 127 out 48399 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) c02874b9
+
+
+  │ 2026-08-30 19:43:58 • assistant • Qwen3.8-27B-Think
+  │
+  │ I need to look into this in more detail. Let me check the details.
+  │
+  │ Update lines 136–138 of the README:
+  │
+  │ edit /home/mac/Code/dashboard/README.md                                              ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/README.md",
+  │       "oldString": "Adding a plugin: create a module in `app/plugins/` defining a
+  │       `Plugin`\ninstance (id, title, poll interval, fragment function) and register it
+  │       in\n`app/plugins/__init__.py`.",
+  │       "newString": "Adding a plugin: create a module in `app/plugins/` defining a
+  │       `Plugin`\ninstance (id, title, skeleton function) and register it
+  │       in\n`app/plugins/__init__.py`. The skeleton is the static card shell, rendered\nonce; it
+  │       embeds the dynamically polled regions (e.g. a div with\n`hx-get`/`hx-trigger=\"every Ns\"`
+  │       pointing at the plugin's own endpoints)."
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 434 in 223 out 48554 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) 4f646ceb
+
+
+  │ 2026-08-30 19:44:04 • assistant • Qwen3.8-27B-Think
+  │
+  │ Next, I'll verify that the entire llamacpp.py is correct, then run compileall + lint + restart +
+  │ curl.
+  │
+  │ read /home/mac/Code/dashboard/app/plugins/llamacpp.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/plugins/llamacpp.py",
+  │       "offset": 88,
+  │       "limit": 75
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/plugins/llamacpp.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     88:
+  │     89:
+  │     90: def _with_lists(status: dict[str, Any]) -> dict[str, Any]:
+  │     91:     active = {m["id"] for m in status["models"] if m["state"] in ("loaded", "sleeping",
+  │     "loading")}
+  │     92:     status["loaded"] = [m for m in status["models"] if m["id"] in active]
+  │     93:     status["available"] = [m for m in status["models"] if m["id"] not in active]
+  │     94:     status["loaded"].sort(key=lambda m: (m["state"] != "loaded", m["state"] !=
+  │     "sleeping", m["id"]))
+  │     95:     status["available"].sort(key=lambda m: m["id"])
+  │     96:     return status
+  │     97:
+  │     98:
+  │     99: async def _status(message: str, error: str) -> dict[str, Any]:
+  │     100:     status = _with_lists(await gather_status())
+  │     101:     status["message"] = message
+  │     102:     status["error_msg"] = error
+  │     103:     return status
+  │     104:
+  │     105:
+  │     106: async def _state(message: str = "", error: str = "") -> str:
+  │     107:     return render("plugins/llamacpp_state.html", **await _status(message, error))
+  │     108:
+  │     109:
+  │     110: async def _skeleton(message: str = "", error: str = "") -> str:
+  │     111:     return render("plugins/llamacpp_skeleton.html", **await _status(message, error))
+  │     112:
+  │     113:
+  │     114: @router.get("/state")
+  │     115: async def state():
+  │     116:     return HTMLResponse(await _state())
+  │     117:
+  │     118:
+  │     119: @router.post("/load")
+  │     120: async def load(model: str = Form(...)):
+  │     121:     ok, err = await _action("/models/load", model)
+  │     122:     return HTMLResponse(
+  │     123:         await _skeleton(
+  │     124:             message=f"loading {model}" if ok else "",
+  │     125:             error="" if ok else err,
+  │     126:         )
+  │     127:     )
+  │     128:
+  │     129:
+  │     130: @router.post("/unload")
+  │     131: async def unload(model: str = Form(...)):
+  │     132:     ok, err = await _action("/models/unload", model)
+  │     133:     return HTMLResponse(
+  │     134:         await _skeleton(
+  │     135:             message=f"unloading {model}" if ok else "",
+  │     136:             error="" if ok else err,
+  │     137:         )
+  │     138:     )
+  │     139:
+  │     140:
+  │     141: @router.post("/rescan")
+  │     142: async de
+  │     … [799 more chars]
+  │
+  │ tokens 18 in 91 out 49212 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:07 • assistant • Qwen3.8-27B-Think
+  │
+  │ Alright. Next, run the verification: compileall, basedpyright, server restart, curl. Let me
+  │ update the todos and run compileall and lint in parallel.
+  │
+  │ todowrite 1 todos                                                                    ok     0.0s
+  │   in
+  │     {
+  │       "todos": [
+  │         {
+  │           "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Split llamacpp templates into skeleton + state",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update llamacpp.py endpoints and Plugin instance",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update templates/plugins.html and README",
+  │           "status": "completed",
+  │           "priority": "medium"
+  │         },
+  │         {
+  │           "content": "Verify: compileall, lint, restart, curl endpoints",
+  │           "status": "in_progress",
+  │           "priority": "high"
+  │         }
+  │       ]
+  │     }
+  │   out
+  │     [
+  │       {
+  │         "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Split llamacpp templates into skeleton + state",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update llamacpp.py endpoints and Plugin instance",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update templates/plugins.html and README",
+  │         "status": "completed",
+  │         "priority": "medium"
+  │       },
+  │       {
+  │         "content": "Verify: compileall, lint, restart, curl endpoints",
+  │         "status": "in_progress",
+  │         "priority": "high"
+  │       }
+  │     ]
+  │ bash uv run python -m compileall -q app && echo COMPILE_OK                           ok     0.0s
+  │   in
+  │     {
+  │       "command": "uv run python -m compileall -q app && echo COMPILE_OK"
+  │     }
+  │   out COMPILE_OK
+  │
+  │ tokens 1004 in 271 out 49320 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:16 • assistant • Qwen3.8-27B-Think
+  │
+  │ Next, I'll run basedpyright. AGENTS.md says "basedpyright is configured as the linter." Let me
+  │ check whether it's available as a uv tool: `uvx basedpyright` or inside the project. I'll try
+  │ `uv run basedpyright` — it's not included in the dependencies, so `uvx --from basedpyright
+  │ basedpyright` might be needed. First let me try `uvx basedpyright app` (or maybe it's already
+  │ installed). Let me check.
+  │
+  │ bash command -v basedpyright || uvx --help >/dev/null 2>&1 && echo HAS_UVX           ok     0.0s
+  │   in
+  │     {
+  │       "command": "command -v basedpyright || uvx --help >/dev/null 2>&1 && echo HAS_UVX"
+  │     }
+  │   out HAS_UVX
+  │
+  │ tokens 262 in 160 out 50596 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:22 • assistant • Qwen3.8-27B-Think
+  │
+  │ basedpyright is not on the PATH, but uvx exists. I'll try `uvx basedpyright` — the first run may
+  │ take some time since it downloads the package. Set a timeout with some margin.
+  │
+  │ bash uvx basedpyright app 2>&1 | tail -20                                            ok     0.0s
+  │   in
+  │     {
+  │       "command": "uvx basedpyright app 2>&1 | tail -20",
+  │       "timeout": 300000
+  │     }
+  │   out
+  │         /home/mac/Code/dashboard/app/__init__.py
+  │         /home/mac/Code/dashboard/app/routers/__init__.py
+  │         /home/mac/Code/dashboard/app/routers/services.py (reportImportCycles)
+  │       /home/mac/Code/dashboard/app/__init__.py:1:17 - warning: Import "routers" is not accessed
+  │       (reportUnusedImport)
+  │     /home/mac/Code/dashboard/app/config.py
+  │       /home/mac/Code/dashboard/app/config.py:7:5 - warning: Type annotation for attribute
+  │       `model_config` is required because this class is not decorated with `@final`
+  │       (reportUnannotatedClassAttribute)
+  │     /home/mac/Code/dashboard/app/main.py
+  │       /home/mac/Code/dashboard/app/main.py:41:15 - warning: Function "index" is not accessed
+  │       (reportUnusedFunction)
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py
+  │       /home/mac/Code/dashboard/app/plugins/llamacpp.py:18:12 - warning: Return type,
+  │       "dict[Unknown, Unknown]", is partially unknown (reportUnknownVariableType)
+  │       /home/mac/Code/dashboard/app/plugins/llamacpp.py:66:46 - warning: Type of parameter "m" is
+  │       unknown (reportUnknownLambdaType)
+  │       /home/mac/Code/dashboard/app/plugins/llamacpp.py:66:49 - warning: Return type of lambda is
+  │       unknown (reportUnknownLambdaType)
+  │       /home/mac/Code/dashboard/app/plugins/llamacpp.py:120:29 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │       /home/mac/Code/dashboard/app/plugins/llamacpp.py:131:31 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │     /home/mac/Code/dashboard/app/routers/services.py
+  │       /home/mac/Code/dashboard/app/routers/services.py:98:19 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │       /home/mac/Code/dashboard/app/routers/services.py:99:14 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │       /home/mac/Code/dashboard/app/routers/services.py:100:17 -
+  │     … [352 more chars]
+  │
+  │ tokens 19 in 105 out 51018 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:30 • assistant • Qwen3.8-27B-Think
+  │
+  │ "2 errors" — I need to check what those errors are. The end only shows warnings. Let's grab the
+  │ full output and filter for errors.
+  │
+  │ bash uvx basedpyright app 2>&1 | grep -B2 "error"                                    ok     0.0s
+  │   in
+  │     {
+  │       "command": "uvx basedpyright app 2>&1 | grep -B2 \"error\"",
+  │       "timeout": 300000
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/app/__init__.py
+  │       /home/mac/Code/dashboard/app/__init__.py: error: Cycle detected in import chain
+  │     --
+  │         /home/mac/Code/dashboard/app/routers/__init__.py
+  │         /home/mac/Code/dashboard/app/routers/journal.py (reportImportCycles)
+  │       /home/mac/Code/dashboard/app/__init__.py: error: Cycle detected in import chain
+  │     --
+  │       /home/mac/Code/dashboard/app/routers/services.py:100:17 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │       /home/mac/Code/dashboard/app/routers/services.py:101:18 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │     2 errors, 12 warnings, 0 notes
+  │
+  │ tokens 598 in 94 out 51141 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:39 • assistant • Qwen3.8-27B-Think
+  │
+  │ The 2 errors are "Cycle detected in import chain" in `app/__init__.py` — is this pre-existing?
+  │ Let me check with git: were these errors there before my changes? My changes didn't touch the
+  │ imports in app/__init__.py or app/routers/__init__.py. Let me verify with git stash... An even
+  │ simpler approach: check `git status` and `git stash` and then run basedpyright? That's heavy.
+  │ Alternative: examine the import chain — `app/__init__.py` imports `routers`, and routers imports
+  │ something that re-imports `app`. Let me look at the files.
+  │
+  │ Actually, an even simpler approach: run basedpyright on a clean checkout (git worktree or `git
+  │ stash`) to confirm these are pre-existing errors. First, let me check the files.
+  │
+  │ bash git stash -u && uvx basedpyright app 2>&1 | tail -3; git stash pop              ok     0.0s
+  │   in
+  │     {
+  │       "command": "git stash -u && uvx basedpyright app 2>&1 | tail -3; git stash pop",
+  │       "timeout": 300000
+  │     }
+  │   out
+  │     Saved working directory and index state WIP on main: 23341d8 Bugfix: Cursor for journal tab
+  │     not applied correctly causing duplicated entries
+  │       /home/mac/Code/dashboard/app/routers/services.py:100:17 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │       /home/mac/Code/dashboard/app/routers/services.py:101:18 - warning: Function calls and
+  │       mutable objects not allowed within parameter default value expression
+  │       (reportCallInDefaultInitializer)
+  │     2 errors, 12 warnings, 0 notes
+  │     On branch main
+  │     Your branch is up to date with 'origin/main'.
+  │
+  │     Changes not staged for commit:
+  │       (use "git add/rm <file>..." to update what will be committed)
+  │       (use "git restore <file>..." to discard changes in working directory)
+  │     	modified:   README.md
+  │     	modified:   app/plugins/base.py
+  │     	modified:   app/plugins/llamacpp.py
+  │     	modified:   app/routers/plugins.py
+  │     	modified:   templates/plugins.html
+  │     	deleted:    templates/plugins/llamacpp.html
+  │
+  │     Untracked files:
+  │       (use "git add <file>..." to include in what will be committed)
+  │     	templates/plugins/llamacpp_skeleton.html
+  │     	templates/plugins/llamacpp_state.html
+  │
+  │     no changes added to commit (use "git add" and/or "git commit -a")
+  │     Dropped refs/stash@{0} (66343aabf91c4068b2d9c84b8ce4fc080ed40aba)
+  │
+  │ tokens 201 in 241 out 51834 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:44:52 • assistant • Qwen3.8-27B-Think
+  │
+  │ The same 2 errors + 12 warnings also exist in the clean tree before my changes — it's a
+  │ pre-existing issue, not caused by my changes. Good.
+  │
+  │ Wait, did the stash pop bring everything back including the untracked templates? Yes: the
+  │ untracked files are listed (they were stashed with -u and then restored with pop).
+  │
+  │ Next, restart the dev server and test the endpoints. Following the restart procedure in
+  │ AGENTS.md.
+  │
+  │ Pre-existing errors (same 2 errors/12 warnings on the pristine tree) — my changes add none. Now
+  │ restart the server and test:
+  │
+  │ bash PID=$(pgrep -f "python main\.py" | head -1); [ -n "$PID" ] && kill "$PID"; s…   ok     4.0s
+  │   in
+  │     {
+  │       "command": "PID=$(pgrep -f \"python main\\.py\" | head -1); [ -n \"$PID\" ] && kill
+  │       \"$PID\"; sleep 1; setsid nohup uv run python main.py > /tmp/dash.log 2>&1 < /dev/null &
+  │       disown; sleep 3; tail -5 /tmp/dash.log",
+  │       "timeout": 30000
+  │     }
+  │   out (no output)
+  │
+  │ tokens 372 in 242 out 52276 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:45:04 • assistant • Qwen3.8-27B-Think
+  │
+  │ Hmm, there's no output at all — not even the tail of the log. Maybe the server is still starting
+  │ up, or the log is empty, or the pgrep+kill chain... let me check: the fact that `tail -5
+  │ /tmp/dash.log` produced no output means the log is either empty or doesn't exist. Let me check
+  │ the process and the log.
+  │
+  │ bash pgrep -af "python main\.py"; ls -la /tmp/dash.log; sleep 2; tail -10 /tmp/da…   ok     2.0s
+  │   in
+  │     {
+  │       "command": "pgrep -af \"python main\\.py\"; ls -la /tmp/dash.log; sleep 2; tail -10
+  │       /tmp/dash.log"
+  │     }
+  │   out
+  │     112342 uv run python main.py
+  │     -rw-r--r-- 1 mac mac 0 30. Aug 19:45 /tmp/dash.log
+  │
+  │ tokens 19 in 139 out 52889 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:45:10 • assistant • Qwen3.8-27B-Think
+  │
+  │ The server process is running (112342), but the log is empty and still empty — uvicorn's output
+  │ might be getting buffered, or it could just be taking a while. Let me try curling the endpoint.
+  │
+  │ bash sleep 2; for ep in /api/plugins /api/plugins/llamacpp/state; do echo "== $ep…   ok     0.1s
+  │   in
+  │     {
+  │       "command": "sleep 2; for ep in /api/plugins /api/plugins/llamacpp/state; do echo \"== $ep:
+  │       $(curl -s -o /dev/null -w \"%{http_code}\" http://127.0.0.1:8501$ep)\"; done",
+  │       "timeout": 30000
+  │     }
+  │   out
+  │     == /api/plugins: 200
+  │     == /api/plugins/llamacpp/state: 200
+  │
+  │ tokens 55 in 154 out 53047 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:45:17 • assistant • Qwen3.8-27B-Think
+  │
+  │ Both endpoints return 200. Next, let's verify the structure of the HTML:
+  │ 1. `/api/plugins` should contain the skeleton: `<div id="llama-state"
+  │ hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s" ...>`, the static select, and the
+  │ rescan button.
+  │ 2. `/api/plugins/llamacpp/state` should contain only the dynamic parts (health/loaded), and must
+  │ not contain the select.
+  │ 3. POST /rescan should return the skeleton (200 + select present).
+  │
+  │ Also, let's check for Tracebacks in the logs.
+  │
+  │ bash curl -s http://127.0.0.1:8501/api/plugins > /tmp/plugins.html; grep -c 'id="…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "curl -s http://127.0.0.1:8501/api/plugins > /tmp/plugins.html; grep -c
+  │       'id=\"llama-state\"' /tmp/plugins.html; grep -o 'hx-get=\"/api/plugins/llamacpp/state\"
+  │       hx-trigger=\"every 5s\" hx-swap=\"innerHTML\"' /tmp/plugins.html; grep -c
+  │       'id=\"llama-model-pick\"' /tmp/plugins.html; grep -c 'rescan models' /tmp/plugins.html;
+  │       echo ---STATE---; curl -s http://127.0.0.1:8501/api/plugins/llamacpp/state >
+  │       /tmp/state.html; grep -c 'llama-model-pick\\|rescan' /tmp/state.html; head -c 400
+  │       /tmp/state.html; echo; echo ---RESCAN---; curl -s -X POST
+  │       http://127.0.0.1:8501/api/plugins/llamacpp/rescan | grep -c 'llama-model-pick'; grep -c
+  │       Traceback /tmp/dash.log"
+  │     }
+  │   out
+  │     1
+  │     hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s" hx-swap="innerHTML"
+  │     0
+  │     1
+  │     ---STATE---
+  │     0
+  │
+  │     <div class="llama-health">
+  │       <span class="dot dot-run"></span>
+  │       <span class="llama-health-text">healthy</span>
+  │       <span class="muted small mono">http://127.0.0.1:8080</span>
+  │     </div>
+  │
+  │
+  │
+  │     <h4>Loaded models</h4>
+  │
+  │     <div class="muted small">no models loaded</div>
+  │
+  │
+  │     ---RESCAN---
+  │     0
+  │     0
+  │
+  │ tokens 38 in 394 out 53257 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:45:28 • assistant • Qwen3.8-27B-Think
+  │
+  │ Interesting results:
+  │
+  │ 1. `/api/plugins`: llama-state slot exists with correct polling attributes ✓, rescan button ✓,
+  │ but `llama-model-pick` count = 0! The select is not being rendered. Why? The skeleton only
+  │ renders the select when `reachable` is truthy AND `available` is non-empty. Looking at the state
+  │ output, it shows "healthy" → so in the state endpoint reachable=True. But in the skeleton, the
+  │ `{% if reachable %}` block — hmm wait, the count for 'rescan models' is 1, which is inside `{%
+  │ if reachable %}`. So reachable is true, but `available` is empty → "no unloaded models" hint
+  │ branch. That's plausible: the server is healthy but there are no available models (no models
+  │ directory / no models). Let me verify by grepping /tmp/plugins.html for "no unloaded models".
+  │
+  │ 2. `/state`: no select/rescan ✓, shows healthy + no models loaded ✓.
+  │
+  │ 3. POST /rescan returned 0 matches for llama-model-pick — consistent: the skeleton with empty
+  │ available → no select. And grep -c Traceback = 0... wait, the last output is "0" — that's the
+  │ count from `grep -c Traceback /tmp/dash.log` = 0? But the log was empty (0 bytes) earlier. Hmm,
+  │ `grep -c` against an empty file outputs 0. OK, no tracebacks.
+  │
+  │ Let me check the full skeleton HTML in /tmp/plugins.html to confirm the structure is correct
+  │ (hint branch).
+  │
+  │ bash cat /tmp/plugins.html                                                           ok     0.0s
+  │   in
+  │     {
+  │       "command": "cat /tmp/plugins.html"
+  │     }
+  │   out
+  │     <div id="plugins" class="panel">
+  │       <div class="muted small">plugins load from <span class="mono">app/plugins/</span> &mdash;
+  │       each module exposes a <span class="mono">Plugin</span> instance</div>
+  │
+  │       <div class="plugin-card">
+  │         <h3>llama.cpp</h3>
+  │         <p class="muted small">Loaded model status for a llama-server in router mode, with load
+  │         / unload controls.</p>
+  │         <div class="plugin-body"><div class="llama">
+  │       <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s"
+  │       hx-swap="innerHTML">
+  │
+  │     <div class="llama-health">
+  │       <span class="dot dot-run"></span>
+  │       <span class="llama-health-text">healthy</span>
+  │       <span class="muted small mono">http://127.0.0.1:8080</span>
+  │     </div>
+  │
+  │
+  │
+  │     <h4>Loaded models</h4>
+  │
+  │     <div class="muted small">no models loaded</div>
+  │
+  │
+  │       </div>
+  │
+  │       <h4>Available models</h4>
+  │
+  │       <div class="muted small">no unloaded models (is --models-dir set on the server?)</div>
+  │
+  │
+  │       <div class="actions">
+  │         <button class="btn" hx-post="/api/plugins/llamacpp/rescan" hx-target="closest
+  │         .plugin-body" hx-swap="innerHTML">rescan models</button>
+  │       </div>
+  │
+  │     </div></div>
+  │       </div>
+  │
+  │     </div>
+  │
+  │ tokens 154 in 362 out 53689 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:45:51 • assistant • Qwen3.8-27B-Think
+  │
+  │ The skeleton is rendering correctly. Since no model exists on the llama-server (healthy but zero
+  │ models), the "no unloaded models" hint is displayed instead of the select — this is the correct
+  │ branch.
+  │
+  │ Next, I want to also verify the branch where models exist (where the select gets rendered). Can
+  │ I test it without an actual model? Options:
+  │ - If a model exists, check the /models response from the running llama-server: curl
+  │ http://127.0.0.1:8080/models.
+  │ - If empty, I could unit-test the template rendering via python with a fake status dict, and
+  │ verify that the select markup renders (render("plugins/llamacpp_skeleton.html", **fake_status)).
+  │
+  │ Let me first check the server's model list, then do a rendering test with fake data covering:
+  │ reachable + models (select), and unreachable (no controls).
+  │
+  │ Skeleton structure is correct (server is healthy but has no models, so the hint branch renders).
+  │ Now verify the other branches render correctly with a direct template test:
+  │
+  │ bash curl -s http://127.0.0.1:8080/models | head -c 300; echo; uv run python -c "…   ok     0.2s
+  │   in
+  │     {
+  │       "command": "curl -s http://127.0.0.1:8080/models | head -c 300; echo; uv run python -c
+  │       \"\nfrom app.plugins.llamacpp import _skeleton, _state\nimport asyncio\nfake =
+  │       {'base_url': 'http://x', 'reachable': True, 'health': 'ok', 'error': None, 'message': '',
+  │       'error_msg': '',\n        'models': [{'id': 'a.gguf', 'state': 'unloaded', 'failed':
+  │       False, 'exit_code': 'None', 'path': '/m/a.gguf'},\n                   {'id': 'b.gguf',
+  │       'state': 'loaded', 'failed': False, 'exit_code': 'None', 'path': '/m/b.gguf'}]}\nimport
+  │       app.plugins.llamacpp as L\norig = L.gather_status\nL.gather_status = lambda:
+  │       _fake()\nasync def _fake(): return __import__('copy').deepcopy(fake)\nsk =
+  │       asyncio.run(_skeleton())\nassert 'id=\\\"llama-model-pick\\\"' in sk and 'a.gguf' in sk
+  │       and 'b.gguf' not in sk.split('id=\\\"llama-model-pick\\\"')[1].split('</select>')[0],
+  │       'select should hold only available models'\nassert 'unload' in sk and 'rescan models' in
+  │       sk\nst = asyncio.run(_state(message='loading a.gguf'))\nassert 'llama-model-pick' not in
+  │       st and 'loading a.gguf' in st and 'b.gguf' in st\nfake['reachable'] = False\nsk2 =
+  │       asyncio.run(_skeleton())\nassert 'llama-model-pick' not in sk2 and 'unreachable' in
+  │       sk2\nprint('TEMPLATE_BRANCHES_OK')\n\""
+  │     }
+  │   out
+  │     {"data":[],"object":"list"}
+  │     TEMPLATE_BRANCHES_OK
+  │
+  │ tokens 382 in 632 out 54206 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:46:11 • assistant • Qwen3.8-27B-Think
+  │
+  │ All branches render correctly:
+  │ - reachable + model → select contains only available models (a.gguf), the loaded list has
+  │ b.gguf, and the unload + rescan buttons are present.
+  │ - state fragment → no select, has message, loaded models are listed.
+  │ - unreachable → no select, alert is shown.
+  │
+  │ The live llama-server indeed has no models, which is consistent.
+  │
+  │ Final checks:
+  │ - Log tracebacks: confirmed 0.
+  │ - Also confirmed that the old /api/plugins/llamacpp/fragment and /api/plugins/llamacpp/fragment
+  │ (generic) return 404 (removed).
+  │ - Verified the frontend: the plugin's tab index.html is unchanged.
+  │
+  │ Also, double-checked that there are no lingering references to the removed route/templates
+  │ (llamacpp.html) anywhere: grep.
+  │
+  │ bash curl -s -o /dev/null -w "old fragment: %{http_code}\n" http://127.0.0.1:8501…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "curl -s -o /dev/null -w \"old fragment: %{http_code}\\n\"
+  │       http://127.0.0.1:8501/api/plugins/llamacpp/fragment; grep -rn
+  │       \"llamacpp.html\\|/fragment\" templates/ app/ static/js/ 2>/dev/null | grep -v vendor;
+  │       grep -c Traceback /tmp/dash.log; curl -s -o /dev/null -w \"overview: %{http_code}\\n\"
+  │       http://127.0.0.1:8501/api/overview"
+  │     }
+  │   out
+  │     old fragment: 404
+  │     0
+  │     overview: 200
+  │
+  │ tokens 28 in 325 out 55220 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:46:21 • assistant • Qwen3.8-27B-Think
+  │
+  │ All good:
+  │ - Old `/fragment` route → 404 (deleted).
+  │ - No old references to `llamacpp.html` or `/fragment` in templates/app/js.
+  │ - 0 Tracebacks in the server log.
+  │ - Other endpoints continue to work.
+  │
+  │ Update the TODO list to complete and summarize concisely.
+  │
+  │ todowrite 0 todos                                                                    ok     0.0s
+  │   in
+  │     {
+  │       "todos": [
+  │         {
+  │           "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Split llamacpp templates into skeleton + state",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update llamacpp.py endpoints and Plugin instance",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update templates/plugins.html and README",
+  │           "status": "completed",
+  │           "priority": "medium"
+  │         },
+  │         {
+  │           "content": "Verify: compileall, lint, restart, curl endpoints",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         }
+  │       ]
+  │     }
+  │   out
+  │     [
+  │       {
+  │         "content": "Update Plugin base (skeleton_fn, drop fragment/poll_seconds)",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update plugins router (skeleton body, drop /{pid}/fragment)",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Split llamacpp templates into skeleton + state",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update llamacpp.py endpoints and Plugin instance",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update templates/plugins.html and README",
+  │         "status": "completed",
+  │         "priority": "medium"
+  │       },
+  │       {
+  │         "content": "Verify: compileall, lint, restart, curl endpoints",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       }
+  │     ]
+  │
+  │ tokens 30 in 267 out 55574 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-30 19:46:28 • assistant • Qwen3.8-27B-Think
+  │
+  │ Done. Brief summary: what was changed, the new behavior, verification results. Keep it short.
+  │
+  │ Done. The plugin card is now split into a static skeleton and a dynamic part:
+  │
+  │ - **Static** (rendered once, never auto-swapped): the `<select>` + load button, rescan button,
+  │ headings — `templates/plugins/llamacpp_skeleton.html`, rendered by `Plugin.skeleton()`
+  │ (`app/plugins/base.py:13`) at tab load and after every load/unload/rescan action.
+  │ - **Dynamic** (5s auto-refresh): health line + loaded-models list only —
+  │ `templates/plugins/llamacpp_state.html`, polled by the `#llama-state` slot into `GET
+  │ /api/plugins/llamacpp/state` (`app/plugins/llamacpp.py:114`).
+  │ - Removed: `fragment_fn`/`poll_seconds` from `Plugin`, the generic `/api/plugins/{pid}/fragment`
+  │ route, and the whole-fragment polling in `templates/plugins.html`. README plugin docs updated.
+  │
+  │ Verified: compileall clean, basedpyright shows only the 2 pre-existing import-cycle errors (same
+  │ on pristine tree), server restarted, `/api/plugins` + `/state` return 200 with correct
+  │ structure, all template branches (models present / none / unreachable) render as expected, no
+  │ tracebacks in `/tmp/dash.log`. Selecting from the dropdown can no longer be interrupted by a
+  │ refresh — it's only replaced when you click load/unload/rescan.
+  │
+  │ tokens 253 in 319 out 55872 cached 0 written $0.0000 stop
+
diff --git a/templates/plugins.html b/templates/plugins.html
index bb5fc1b..4a678ca 100644
--- a/templates/plugins.html
+++ b/templates/plugins.html
@@ -4,7 +4,7 @@
   <div class="plugin-card">
     <h3>{{ item.p.title }}</h3>
     <p class="muted small">{{ item.p.description }}</p>
-    <div class="plugin-body" hx-get="/api/plugins/{{ item.p.id }}/fragment" hx-trigger="every {{ item.p.poll_seconds }}s" hx-swap="innerHTML">{{ item.frag | safe }}</div>
+    <div class="plugin-body">{{ item.body | safe }}</div>
   </div>
   {% else %}
   <div class="muted">no plugins registered</div>
diff --git a/templates/plugins/llamacpp.html b/templates/plugins/llamacpp.html
deleted file mode 100644
index 0acba10..0000000
--- a/templates/plugins/llamacpp.html
+++ /dev/null
@@ -1,51 +0,0 @@
-<div class="llama">
-  {% if not reachable %}
-  <div class="alert">llama-server unreachable at <span class="mono">{{ base_url }}</span>{% if error %}: {{ error }}{% endif %}</div>
-  <div class="muted small">start it in router mode: <span class="mono">llama-server --models-dir /path/to/models</span></div>
-  {% else %}
-  <div class="llama-health">
-    <span class="dot {{ "dot-run" if health == "ok" else "dot-failed" }}"></span>
-    <span class="llama-health-text">{{ "healthy" if health == "ok" else (health or "status unknown") }}</span>
-    <span class="muted small mono">{{ base_url }}</span>
-  </div>
-  {% if message %}<div class="notice">{{ message }}</div>{% endif %}
-  {% if error_msg %}<div class="alert">{{ error_msg }}</div>{% endif %}
-
-  <h4>Loaded models</h4>
-  {% if loaded %}
-  <div class="llama-models">
-    {% for m in loaded %}
-    <div class="llama-model">
-      <span class="dot {{ "dot-run" if m.state == "loaded" else ("dot-sleep" if m.state == "sleeping" else ("dot-failed" if m.failed else "dot-busy")) }}"></span>
-      <span class="mono llama-id" title="{{ m.path }}">{{ m.id }}</span>
-      <span class="badge badge-{{ "failed" if m.failed else m.state }}">{{ m.state }}{% if m.failed %} (exit {{ m.exit_code }}){% endif %}</span>
-      {% if m.progress is not none %}<div class="bar small-bar"><div class="bar-fill" style="width: {{ m.progress }}%"></div></div>{% endif %}
-      <span class="llama-model-actions">
-        <button class="btn" hx-post="/api/plugins/llamacpp/unload" hx-vals='{"model":"{{ m.id }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML" hx-confirm="Unload {{ m.id }}?">unload</button>
-      </span>
-    </div>
-    {% endfor %}
-  </div>
-  {% else %}
-  <div class="muted small">no models loaded</div>
-  {% endif %}
-
-  <h4>Available models</h4>
-  {% if available %}
-  <div class="llama-load">
-    <select id="llama-model-pick" name="model">
-      {% for m in available %}
-      <option value="{{ m.id }}">{{ m.id }}{% if m.failed %} (failed, exit {{ m.exit_code }}){% endif %}</option>
-      {% endfor %}
-    </select>
-    <button class="btn" hx-post="/api/plugins/llamacpp/load" hx-include="#llama-model-pick" hx-target="closest .plugin-body" hx-swap="innerHTML">load</button>
-  </div>
-  {% else %}
-  <div class="muted small">no unloaded models (is --models-dir set on the server?)</div>
-  {% endif %}
-
-  <div class="actions">
-    <button class="btn" hx-post="/api/plugins/llamacpp/rescan" hx-target="closest .plugin-body" hx-swap="innerHTML">rescan models</button>
-  </div>
-  {% endif %}
-</div>
diff --git a/templates/plugins/llamacpp_skeleton.html b/templates/plugins/llamacpp_skeleton.html
new file mode 100644
index 0000000..140e0e8
--- /dev/null
+++ b/templates/plugins/llamacpp_skeleton.html
@@ -0,0 +1,24 @@
+<div class="llama">
+  <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s" hx-swap="innerHTML">
+    {% include "plugins/llamacpp_state.html" %}
+  </div>
+  {% if reachable %}
+  <h4>Available models</h4>
+  {% if available %}
+  <div class="llama-load">
+    <select id="llama-model-pick" name="model">
+      {% for m in available %}
+      <option value="{{ m.id }}">{{ m.id }}{% if m.failed %} (failed, exit {{ m.exit_code }}){% endif %}</option>
+      {% endfor %}
+    </select>
+    <button class="btn" hx-post="/api/plugins/llamacpp/load" hx-include="#llama-model-pick" hx-target="closest .plugin-body" hx-swap="innerHTML">load</button>
+  </div>
+  {% else %}
+  <div class="muted small">no unloaded models (is --models-dir set on the server?)</div>
+  {% endif %}
+
+  <div class="actions">
+    <button class="btn" hx-post="/api/plugins/llamacpp/rescan" hx-target="closest .plugin-body" hx-swap="innerHTML">rescan models</button>
+  </div>
+  {% endif %}
+</div>
diff --git a/templates/plugins/llamacpp_state.html b/templates/plugins/llamacpp_state.html
new file mode 100644
index 0000000..ad68127
--- /dev/null
+++ b/templates/plugins/llamacpp_state.html
@@ -0,0 +1,31 @@
+{% if not reachable %}
+<div class="alert">llama-server unreachable at <span class="mono">{{ base_url }}</span>{% if error %}: {{ error }}{% endif %}</div>
+<div class="muted small">start it in router mode: <span class="mono">llama-server --models-dir /path/to/models</span></div>
+{% else %}
+<div class="llama-health">
+  <span class="dot {{ "dot-run" if health == "ok" else "dot-failed" }}"></span>
+  <span class="llama-health-text">{{ "healthy" if health == "ok" else (health or "status unknown") }}</span>
+  <span class="muted small mono">{{ base_url }}</span>
+</div>
+{% if message %}<div class="notice">{{ message }}</div>{% endif %}
+{% if error_msg %}<div class="alert">{{ error_msg }}</div>{% endif %}
+
+<h4>Loaded models</h4>
+{% if loaded %}
+<div class="llama-models">
+  {% for m in loaded %}
+  <div class="llama-model">
+    <span class="dot {{ "dot-run" if m.state == "loaded" else ("dot-sleep" if m.state == "sleeping" else ("dot-failed" if m.failed else "dot-busy")) }}"></span>
+    <span class="mono llama-id" title="{{ m.path }}">{{ m.id }}</span>
+    <span class="badge badge-{{ "failed" if m.failed else m.state }}">{{ m.state }}{% if m.failed %} (exit {{ m.exit_code }}){% endif %}</span>
+    {% if m.progress is not none %}<div class="bar small-bar"><div class="bar-fill" style="width: {{ m.progress }}%"></div></div>{% endif %}
+    <span class="llama-model-actions">
+      <button class="btn" hx-post="/api/plugins/llamacpp/unload" hx-vals='{"model":"{{ m.id }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML" hx-confirm="Unload {{ m.id }}?">unload</button>
+    </span>
+  </div>
+  {% endfor %}
+</div>
+{% else %}
+<div class="muted small">no models loaded</div>
+{% endif %}
+{% endif %}