diff --git a/opencode/012_opencode_session_selective_refresh_2026-08-31.txt b/opencode/012_opencode_session_selective_refresh_2026-08-31.txt
new file mode 100644
index 0000000..7d75ecd
--- /dev/null
+++ b/opencode/012_opencode_session_selective_refresh_2026-08-31.txt
@@ -0,0 +1,2396 @@
+dashboard  2026-08-30 02:43:20 → now  1 session(s)
+
+Session  Started           Where  Title
+3MxAZN   2026-08-31 01:53  .      Active tab reload and background pause
+
+
+ ⚑ ❬3MxAZN❭ Active tab reload and background pause                                  ~/Code/dashboard
+────────────────────────────────────────────────────────────────────────────────────────────────────
+
+  │ 2026-08-31 01:53:13 • user
+  │
+  │ Can we only reload the tab that is currently active and pause updates on background tabs?
+
+
+  │ 2026-08-31 01:53:13 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ The user is asking whether only the currently active tab can be reloaded, and whether updates
+  │ can be paused on background tabs. This is a feature request/question about the dashboard
+  │ project. We're in plan mode, so we need to explore the codebase to understand how tabs work, and
+  │ then formulate a plan.
+  │
+  │ Let's explore the codebase to understand the tab structure and how updates currently work.
+  │
+  │ task Explore the dashboard codebase at /home/mac/Code/dashboard. I need to unders…   ok   551.6s
+  │   in
+  │     {
+  │       "description": "Explore tab structure",
+  │       "prompt": "Explore the dashboard codebase at /home/mac/Code/dashboard. I need to
+  │       understand the tab system in detail:\n\n1. Read templates/ directory - list all files, and
+  │       read the main index template (probably templates/index.html) and 2-3 example tab templates
+  │       (e.g. overview.html, disks.html, processes.html or similar)\n2. How are tabs structured?
+  │       Look for tab navigation markup, tab switching mechanism (JS, htmx attributes, classes like
+  │       .active)\n3. How does polling work? Look for hx-get, hx-trigger, hx-swap attributes -
+  │       which elements poll, at what intervals\n4. Is there any existing JavaScript in the
+  │       templates or static/ files? Read any .js files found\n5. Check if there's a static/
+  │       directory with CSS/JS\n6. Look at how the tab buttons work - is it pure htmx, or is there
+  │       JS handling tab activation?\n7. Check app/routers/ for any tab-related endpoints\n\nReport
+  │       back with:\n- Exact file listing of templates/ and static/ (if exists)\n- The full content
+  │       of the main index.html template\n- Full content of 2-3 representative tab templates
+  │       (showing their polling setup)\n- Any existing JS code\n- How tab switching currently works
+  │       (the exact mechanism)\n- Polling intervals used per tab/section\n\nBe very thorough -
+  │       include actual code snippets with line numbers.",
+  │       "subagent_type": "explore"
+  │     }
+  │   out
+  │     <task id="ses_faae80776ffeROQ2eyuECh6QXt" state="completed">
+  │     <task_result>
+  │     I now have a complete picture of the tab system. Here is the thorough report.
+  │
+  │     # Dashboard Tab System — Full Analysis
+  │
+  │     ## 1. File Listings
+  │
+  │     ### `templates/` (absolute paths)
+  │     ```
+  │     /home/mac/Code/dashboard/templates/index.html          (4442 B) — SPA shell: tab bar + all
+  │     section containers
+  │     /home/mac/Code/dashboard/templates/overview.html       (4057 B) — Overview fragment (cards)
+  │     /home/mac/Code/dashboard/templates/disks.html          (2013 B) — Disks fragment
+  │     /home/mac/Code/dashboard/templates/processes.html      (2052 B) — Processes fragment
+  │     /home/mac/Code/dashboard/templates/journal.html        ( 404 B) — Journal fragment (line
+  │     batch)
+  │     /home/mac/Code/dashboard/templates/services.html       (4024 B) — Services fragment
+  │     /home/mac/Code/dashboard/templates/service_detail.html (1112 B) — Service accordion detail
+  │     fragment
+  │     /home/mac/Code/dashboard/templates/plugins.html        ( 326 B) — Plugins fragment (wraps
+  │     skeletons)
+  │     /home/mac/Code/dashboard/templates/plugins/
+  │     ├── llamacpp_skeleton.html  ( 982 B)
+  │     ├── llamacpp_state.html     (1705 B)
+  │     ├── sleep_skeleton.html     ( 182 B)
+  │     ├── sleep_state.html        (1502 B)
+  │     ├── lact_skeleton.html      (1011 B)
+  │     ├── lact_state.html         ( 713 B)
+  │     └── sessions_skeleton.html  ( 194 B)
+  │         sessions_state.html     (1091 B)
+  │     ```
+  │
+  │     ### `static/` (exists)
+  │     ```
+  │     /home/mac/Code/dashboard/static/css/style.css          (9441 B)
+  │     /home/mac/Code/dashboard/static/js/app.js              (8178 B) — the only hand-written JS
+  │     /home/mac/Code/dashboard/static/vendor/htmx.min.js     (48101 B)
+  │     /home/mac/Code/dashboard/static/vendor/chart.umd.min.js(205125 B)
+  │     ```
+  │     No other `.js` files exist in the repo (verified by glob: only `app.js` + the two vendor
+  │     libs).
+  │
+  │     ---
+  │
+  │     ## 2. Full Content of `templates/index.html` (the SPA shell)
+  │
+  │     ```html
+  │       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: <t
+  │     … [36347 more chars]
+  │
+  │ tokens 9727 in 431 out 0 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:03:01 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Now I have a full picture of the tab system. Let me think about what the user is asking:
+  │
+  │ "Can we only reload the currently active tab, and pause updates for background tabs?"
+  │
+  │ So the user's request is:
+  │ 1. Only fetch/reload the currently active tab
+  │ 2. Pause updates (polling) for background (hidden) tabs
+  │
+  │ Currently, all tabs poll simultaneously from page load. htmx doesn't pause `hx-trigger="every
+  │ Ns"` for hidden elements.
+  │
+  │ Key elements:
+  │ 1. **htmx polling elements**: `#overview` (2s), `#disks` (2s), `#processes-body` (3s),
+  │ `#journal-log` (5s), `#services` (15s), four plugin state divs (5s each)
+  │ 2. **JS polling**: `setInterval(pollHistory, 2000)` for the charts (which live on the Overview
+  │ tab)
+  │
+  │ How to pause/resume htmx polling?
+  │
+  │ Options:
+  │
+  │ **Option A: htmx's `htmx.pausePolling()` / resume.** htmx has a built-in `htmx.pausePolling()`
+  │ function that pauses all polling globally (used with `visibilitychange` in some setups). But
+  │ this is global, not per-element. Hmm. Actually, does htmx have element-level pause? Let me
+  │ think...
+  │
+  │ In htmx 1.x/2.x there's:
+  │ - `htmx.pausePolling()` — pauses all polling
+  │ - In htmx 2.x, there's a concept of... Actually let me recall the htmx 2.0 API. htmx 2.0
+  │ (current) has:
+  │   - `htmx.trigger` / `htmx.triggerError`
+  │   - `htmx.pausePolling()` — global pause
+  │   - No per-element pause API in htmx 2.x? Hmm.
+  │
+  │ Actually, I recall htmx has no official per-element pause. Common pattern:
+  │
+  │ 1. **Global visibility-based pause**: Use `document.addEventListener('visibilitychange', ...)`
+  │ and call `htmx.pausePolling()` when the page is hidden, resume when visible. But this is about
+  │ page visibility, not tab visibility.
+  │
+  │ 2. **Per-tab pause via trigger removal**: On tab switch, modify `hx-trigger` attribute or
+  │ remove/add timers. One approach:
+  │    - Give each polling element a custom trigger name (e.g. `hx-trigger="dash-tick"`), and have
+  │    JS dispatch a custom event on the active tab's polling elements every N ms. But that requires
+  │    per-tab interval management.
+  │
+  │ 3. **A simp
+  │ … [30031 more chars]
+  │
+  │ I have a full picture of the tab system now. Let me verify a few implementation details before
+  │ finalizing the plan.
+  │
+  │ grep hx-trigger                                                                      ok     0.1s
+  │   in
+  │     {
+  │       "pattern": "hx-trigger",
+  │       "path": "/home/mac/Code/dashboard/templates"
+  │     }
+  │   out
+  │     Found 14 matches
+  │     /home/mac/Code/dashboard/templates/processes.html:
+  │       Line 1: <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="every
+  │       3s" hx-swap="outerHTML" hx-include="#proc-controls">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html:
+  │       Line 2:   <div id="sessions-state" hx-get="/api/plugins/sessions/state" hx-trigger="every
+  │       5s" hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/disks.html:
+  │       Line 1: <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="every 2s"
+  │       hx-swap="outerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html:
+  │       Line 2:   <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s"
+  │       hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/lact_skeleton.html:
+  │       Line 2:   <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="every 5s"
+  │       hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/overview.html:
+  │       Line 1: <div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="every
+  │       2s" hx-swap="outerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/services.html:
+  │       Line 1: <div id="services" class="panel" hx-get="/api/services" hx-trigger="every 15s"
+  │       hx-swap="outerHTML" hx-include="#svc-filters">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html:
+  │       Line 2:   <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="every 5s"
+  │       hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/index.html:
+  │       Line 25:     <div id="overview" class="panel" hx-get="/api/overview" hx-trigger="load,
+  │       every 2s" hx-swap="outerHTML"></div>
+  │
+  │       Line 34:     <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="load, every 2s"
+  │       hx-swap="outerHTML"></div>
+  │
+  │       Line 55:     <div id="processes-body" class="panel" hx-get="/api/processes"
+  │       hx-trigger="load, every 3s" hx-swap="outerHTML" hx-include="#proc-controls"></div>
+  │
+  │       Line 73:       <div id="journal-log" hx-get="/api/journal" hx-trigger="load, every 5s"
+  │       hx-swap="befo
+  │     … [329 more chars]
+  │ grep version                                                                         ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "version",
+  │       "path": "/home/mac/Code/dashboard/static/vendor",
+  │       "include": "htmx.min.js"
+  │     }
+  │   out
+  │     Found 1 matches
+  │     /home/mac/Code/dashboard/static/vendor/htmx.min.js:
+  │       Line 1: (function(e,t){if(typeof define==="function"&&define.amd){define([],t)}else
+  │       if(typeof
+  │       module==="object"&&module.exports){module.exports=t()}else{e.htmx=e.htmx||t()}})(typeof
+  │       self!=="undefined"?self:this,function(){return function(){"use strict";var
+  │       Q={onLoad:F,process:zt,on:de,off:ge,trigger:ce,ajax:Nr,find:C,findAll:f,closest:v,values:f
+  │       unction(e,t){var r=dr(e,t||"post");return
+  │       r.values},remove:_,addClass:z,removeClass:n,toggleClass:$,takeClass:W,defineExtension:Ur,r
+  │       emoveExtension:Br,logAll:V,logNone:j,logger:null,config:{historyEnabled:true,historyCacheS
+  │       ize:10,refreshOnHistoryMiss:false,defaultSwapStyle:"innerHTML",defaultSwapDelay:0,defaultS
+  │       ettleDelay:20,includeIndicatorStyles:true,indicatorClass:"htmx-indicator",requestClass:"ht
+  │       mx-request",addedClass:"htmx-added",settlingClass:"htmx-settling",swappingClass:"htmx-swap
+  │       ping",allowEval:true,allowScriptTags:true,inlineScriptNonce:"",attributesToSettle:["class"
+  │       ,"style","width","height"],withCredentials:false,timeout:0,wsReconnectDelay:"full-jitter",
+  │       wsBinaryType:"blob",disableSelector:"[hx-disable],
+  │       [data-hx-disable]",useTemplateFragments:false,scrollBehavior:"smooth",defaultFocusScroll:f
+  │       alse,getCacheBusterParam:false,globalViewTransitions:false,methodsThatUseUrlParams:["get"]
+  │       ,selfRequestsOnly:false,ignoreTitle:false,scrollIntoViewOnBoost:true,triggerSpecsCache:nul
+  │       l},parseInterval:d,_:t,createEventSource:function(e){return new
+  │       EventSource(e,{withCredentials:true})},createWebSocket:function(e){var t=new
+  │       WebSocket(e,[]);t.binaryType=Q.config.wsBinaryType;return t},version:"1.9.12"};var
+  │       r={addTriggerHandler:Lt,bodyContains:se,canAccessLocalStorage:U,findThisElement:xe,filterV
+  │       alues:yr,hasAttribute:o,getAttributeValue:te,getClosestAttributeValue:ne,getClosestMatch:c
+  │       ,getExpressionVars:Hr,getHeaders:xr,getInputValues:dr,getInternalData:ae,getSwapSpecificat
+  │       ion:wr,getTriggerSpecs:it,getTarget:ye,makeFragment:l,mergeObjects:le,makeSettleInfo:T,oob
+  │       Swap:E
+  │     … [81 more chars]
+  │ read /home/mac/Code/dashboard/app/journal.py                                         ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/journal.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/journal.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: import json
+  │     2: import re
+  │     3: from datetime import UTC, datetime
+  │     4: from typing import Any, cast
+  │     5:
+  │     6: from app.utils.subprocess import run_async
+  │     7:
+  │     8: CURSOR_RE = re.compile(r"^[A-Za-z0-9;:=+./_-]+$")
+  │     9: LEVELS = {"all": None, "warn": "warning", "err": "err"}
+  │     10:
+  │     11:
+  │     12: def parse_lines(text: str) -> list[dict[str, Any]]:
+  │     13:     """Parse `journalctl -o json` output into entry dicts.
+  │     14:
+  │     15:     Each non-empty line is one JSON object. Multi-line messages are
+  │     16:     embedded as \\n escapes and control characters (e.g. NUL) are
+  │     17:     JSON-escaped, so no continuation-line handling is needed — the
+  │     18:     former -o export format required both.
+  │     19:
+  │     20:     Args:
+  │     21:         text: raw `journalctl -o json` output.
+  │     22:
+  │     23:     Returns:
+  │     24:         One dict per entry; lines that are not valid JSON objects are
+  │     25:         skipped.
+  │     26:     """
+  │     27:     entries: list[dict[str, Any]] = []
+  │     28:     for line in text.splitlines():
+  │     29:         line = line.strip()
+  │     30:         if not line:
+  │     31:             continue
+  │     32:         try:
+  │     33:             e = json.loads(line)
+  │     34:         except ValueError:
+  │     35:             continue
+  │     36:         if isinstance(e, dict):
+  │     37:             entries.append(cast("dict[str, Any]", e))
+  │     38:     return entries
+  │     39:
+  │     40:
+  │     41: def format_entries(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
+  │     42:     """Reduce raw export entries to the fields the journal tab renders.
+  │     43:
+  │     44:     Entries without a realtime timestamp are dropped. The local time is
+  │     45:     formatted as HH:MM:SS (invalid timestamps render as an empty string),
+  │     46:     PRIORITY defaults to 6 (info), and the identifier falls back
+  │     47:     SYSLOG_IDENTIFIER -> _COMM -> _PID. A MESSAGE that is a JSON array —
+  │     48:     journald encodes non-UTF-8 payloads as byte lists and multi-value
+  │     49:     fields as string lists — is decoded or joined into a single line.
+  │     50:
+  │     51:     Args:
+  │     52:         entries: dicts from pa
+  │     … [4353 more chars]
+  │
+  │ tokens 13232 in 8361 out 10159 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:08:30 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ Key findings:
+  │
+  │ 1. **htmx version is 1.9.12** (not 2.x!). In htmx 1.9.x:
+  │    - Custom DOM event triggers are supported: `hx-trigger="my-event"` works (htmx 1.x supports
+  │    arbitrary event names, e.g., `hx-trigger="click"`).
+  │    - The `from` syntax: `hx-trigger="click from #parent"` — yes, supported in 1.x.
+  │    - Let's verify how htmx 1.9 handles custom event names: in htmx 1.x's `addTriggerToElement`,
+  │    it parses the trigger spec, and for events that aren't `every`, `load`, etc., it calls
+  │    `internalData.trigger...` and attaches a DOM event listener via
+  │    `node.addEventListener(triggerSpec.trigger, ...)`. Actually, the specific logic is: `if
+  │    (triggerSpec.eventName === "revealed" || ...)` ... in 1.9.12, `addTriggerHandling` → for each
+  │    trigger spec: if `trigger` is a known interval → interval; if "load" → ...; otherwise → `if
+  │    (eventTarget === undefined) eventTarget = node` etc., then
+  │    `eventTarget.addEventListener(trigger, handler)`. Yes, arbitrary DOM events work.
+  │
+  │    One caveat about htmx 1.9 + `from`: `getTriggerSpecs` parses `trigger from node`. The event
+  │    listener is attached to the `from` node, and when the event fires, the handler checks... in
+  │    1.9, `Lt` (addTriggerHandler): `if (fromNode) { fromNode.addEventListener(trigger, ...) }`.
+  │    When the event fires on the fromNode, the handler calls `handleEvent`. There's a subtle
+  │    point: does the handler verify that `event.target` is within `thisEl`? In htmx 1.x, I don't
+  │    think there's a target-containment check for `from` (that's `on` / the extension syntax). It
+  │    just fires. Let me grep the minified code for "from" handling to quickly confirm... the
+  │    minified code is hard to read, but I can look for the trigger parsing. Let me try grepping
+  │    for "split" or trigger spec parsing.
+  │
+  │    Actually, let's confirm that custom events + from work in 1.9.12. I recall htmx 1.x docs:
+  │    "hx-trigger='click from #el'" is documented. And custom events: "you can use any DOM event".
+  │    Example: `hx-trigger="myCustomEvent"`. Both are documented features of 1.9. I'm
+  │ … [3623 more chars]
+  │
+  │ I've confirmed htmx **1.9.12** (not 2.x), and I need to verify whether its `from` trigger syntax
+  │ and custom event support can be trusted. Let's check the vendor's source code and the journal
+  │ router.
+  │
+  │ bash grep -o 'from *"[^"]*"\|"[^"]* from [^"]*"' /home/mac/Code/dashboard/static/…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "grep -o 'from *\"[^\"]*\"\\|\"[^\"]* from [^\"]*\"'
+  │       /home/mac/Code/dashboard/static/vendor/htmx.min.js | head -5; grep -c 'revealed'
+  │       /home/mac/Code/dashboard/static/vendor/htmx.min.js"
+  │     }
+  │   out
+  │     from"&&i[0]==="
+  │     " from "
+  │     1
+  │ read /home/mac/Code/dashboard/app/routers/journal.py                                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/routers/journal.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/routers/journal.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from typing import Any
+  │     2:
+  │     3: from fastapi import APIRouter, Request
+  │     4: from fastapi.responses import HTMLResponse
+  │     5:
+  │     6: from app import journal
+  │     7: from app.render import render
+  │     8:
+  │     9: router = APIRouter(prefix="/api", tags=["journal"])
+  │     10:
+  │     11:
+  │     12: @router.get("/journal")
+  │     13: async def journal_view(
+  │     14:     _request: Request,
+  │     15:     level: str = "all",
+  │     16:     unit: str = "",
+  │     17:     search: str = "",
+  │     18:     cursor: str = "",
+  │     19:     hide_sudo: str = "",
+  │     20: ):
+  │     21:     """Render the Journal tab fragment: a page of journal entries.
+  │     22:
+  │     23:     Without a cursor it fetches 100 lines; with one (continuing a scroll)
+  │     24:     200, then keeps the newest 400 for the template. level is validated
+  │     25:     against journal.LEVELS, and failures (RuntimeError/OSError from
+  │     26:     journalctl) are rendered as an error banner instead of a 500.
+  │     27:
+  │     28:     Args:
+  │     29:         _request: FastAPI request (unused).
+  │     30:         level: "all" / "warn" / "err".
+  │     31:         unit: unit name filter, empty for none.
+  │     32:         search: free-text filter, empty for none.
+  │     33:         cursor: journal cursor to continue after, empty for none.
+  │     34:         hide_sudo: "on" to hide sudo's own log entries.
+  │     35:
+  │     36:     Returns:
+  │     37:         The rendered journal.html as an HTMLResponse.
+  │     38:     """
+  │     39:     if level not in journal.LEVELS:
+  │     40:         level = "all"
+  │     41:     lines = 200 if cursor else 100
+  │     42:     error = None
+  │     43:     entries: list[dict[str, Any]] = []
+  │     44:     next_cursor = ""
+  │     45:     try:
+  │     46:         entries, nc = await journal.tail(
+  │     47:             cursor or None,
+  │     48:             level,
+  │     49:             unit or None,
+  │     50:             search or None,
+  │     51:             lines,
+  │     52:             hide_sudo=(hide_sudo == "on"),
+  │     53:         )
+  │     54:         next_cursor = nc or ""
+  │     55:         entries = entries[-400:]
+  │     56:     except (RuntimeError, OSError) as e:
+  │     57:         error = str(e)[:300]
+  │     58:     return HTMLResp
+  │     … [314 more chars]
+  │
+  │ tokens 11779 in 1765 out 23387 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:10:00 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ The minified htmx contains the string `" from "` — this is the trigger `from` parsing. Good.
+  │ Let's look at the surrounding code to confirm that the `from` syntax is parsed and that custom
+  │ events are attached via addEventListener. Let's extract the region around `" from "` in the
+  │ minified file.
+  │
+  │ Journal: no cursor → 100 lines, with cursor → 200 lines, keeping the latest 400 lines. So when
+  │ catching up: 200 entries per tick. No problem.
+  │
+  │ Let's check the htmx minified code around " from " to confirm the parsing and custom event
+  │ attachment.
+  │
+  │ The journal fetches 100/200 lines per tick, so backlog catch-up is bounded. Now let me confirm
+  │ htmx 1.9.12's trigger parsing handles custom events + `from`:
+  │
+  │ bash python3 - <<'EOF' src = open('/home/mac/Code/dashboard/static/vendor/htmx.mi…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "python3 - <<'EOF'\nsrc =
+  │       open('/home/mac/Code/dashboard/static/vendor/htmx.min.js').read()\ni = src.index('\" from
+  │       \"')\nprint(src[i-1200:i+800])\nEOF"
+  │     }
+  │   out (Q.config.settlingClass)}ce(e,"htmx:afterSwap",u)});if(O(f,/HX-Trigger-After-Swap:/i)){var
+  │   o=l;if(!se(l)){o=re().body}_e(f,"HX-Trigger-After-Swap",o)}var
+  │   s=function(){oe(n.tasks,function(e){e.call()});oe(n.elts,function(e){if(e.classList){e.classLi
+  │   st.remove(Q.config.settlingClass)}ce(e,"htmx:afterSettle",u)});if(u.pathInfo.anchor){var
+  │   e=re().getElementById(u.pathInfo.anchor);if(e){e.scrollIntoView({block:"start",behavior:"auto"
+  │   })}}if(n.title&&!p){var
+  │   t=C("title");if(t){t.innerHTML=n.title}else{window.document.title=n.title}}Cr(n.elts,v);if(O(f
+  │   ,/HX-Trigger-After-Settle:/i)){var
+  │   r=l;if(!se(l)){r=re().body}_e(f,"HX-Trigger-After-Settle",r)}ie(m)};if(v.settleDelay>0){setTim
+  │   eout(s,v.settleDelay)}else{s()}}catch(e){fe(l,"htmx:swapError",u);ie(x);throw e}};var
+  │   b=Q.config.globalViewTransitions;if(v.hasOwnProperty("transition")){b=v.transition}if(b&&ce(l,
+  │   "htmx:beforeTransition",u)&&typeof Promise!=="undefined"&&document.startViewTransition){var
+  │   w=new Promise(function(e,t){m=e;x=t});var
+  │   S=y;y=function(){document.startViewTransition(function(){S();return
+  │   w})}}if(v.swapDelay>0){setTimeout(y,v.swapDelay)}else{y()}}if(a){fe(l,"htmx:responseError",le(
+  │   {error:"Response Status Error Code "+f.status+" from "+u.pathInfo.requestPath},u))}}var
+  │   Xr={};function Dr(){return{init:function(e){return null},onEvent:function(e,t){return
+  │   true},transformResponse:function(e,t,r){return e},isInlineSwap:function(e){return
+  │   false},handleSwap:function(e,t,r,n){return false},encodeParameters:function(e,t,r){return
+  │   null}}}function Ur(e,t){if(t.init){t.init(r)}Xr[e]=le(Dr(),t)}function Br(e){delete
+  │   Xr[e]}function Fr(e,r,n){if(e==undefined){return
+  │   r}if(r==undefined){r=[]}if(n==undefined){n=[]}var
+  │   t=te(e,"hx-ext");if(t){oe(t.split(","),function(e){e=e.replace(/
+  │   /g,"");if(e.slice(0,7)=="ignore:"){n.push(e.slice(7));return}if(n.indexOf(e)<0){var
+  │   t=Xr[e];if(t&&r.indexOf(t)<0){r.push(t)}}})}return Fr(u(e),r,n)}var
+  │   Vr=false;re().addEventListener("DOMContentLoaded",function(){Vr=true});function
+  │   jr(e){if(Vr||re().re
+  │
+  │ tokens 2566 in 264 out 35162 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:10:15 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ That hit was inside the "Response Status Error Code" message, not the trigger parser. Let me
+  │ look for the trigger specification parser. In htmx 1.9.12, `getTriggerSpecs` handles things like
+  │ `every 2s`, `load`, etc. Let me search for how it splits trigger values — search for occurrences
+  │ of `" from "`... there's only one occurrence, and that was inside an error message string. Hmm,
+  │ wait, the grep output showed two lines:
+  │ ```
+  │ from"&&i[0]==="
+  │ " from "
+  │ ```
+  │ The first is a fragment like `...from"&&i[0]==="...`, and the second is `" from "`. So there are
+  │ actually two matches, and python's `index` found the first one (the error message). Let me look
+  │ for the second occurrence.
+  │
+  │ That was the error message string. Let me find the actual trigger parser:
+  │
+  │ bash python3 - <<'EOF' src = open('/home/mac/Code/dashboard/static/vendor/htmx.mi…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "python3 - <<'EOF'\nsrc =
+  │       open('/home/mac/Code/dashboard/static/vendor/htmx.min.js').read()\ni = src.index('\" from
+  │       \"', src.index('\" from \"') + 1)\nprint(src[i-2500:i+1500])\nEOF"
+  │     }
+  │   out
+  │     Traceback (most recent call last):
+  │       File "<stdin>", line 2, in <module>
+  │     ValueError: substring not found
+  │
+  │ tokens 643 in 283 out 37993 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:10:27 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ In other words, `" from "` appears only once, and that's inside an error message. So does that
+  │ mean htmx 1.9.12's minified file doesn't contain the `" from "` string used for trigger parsing?
+  │ Wait a sec — maybe the minifier wrote it differently, or maybe the trigger parsing is using
+  │ something else. Let me search for how triggers get parsed. In htmx 1.9.12's source,
+  │ `getTriggerSpecs` looks like this:
+  │
+  │ ```js
+  │ function getTriggerSpecs(elem) {
+  │   ...
+  │   var trigger = getAttributeValue(elem, 'hx-trigger');
+  │   if (trigger) {
+  │     var triggerSpecs = triggerSpecsCache...
+  │     ...
+  │     var parts = trigger.split(",");
+  │     ...
+  │     var parts = trigger.split(" ");  // something like that?
+  │ ```
+  │
+  │ Hmm, actually in 1.9.x:
+  │
+  │ ```js
+  │ function getTriggerSpecs(elem) {
+  │   var trigger = getAttributeValue(elem, 'hx-trigger');
+  │   ...
+  │   function getTriggerSpecsForElement...
+  │ ```
+  │
+  │ To understand the parsing, let me search for the minified `it` function (getTriggerSpecs). Let
+  │ me search for "not" (in htmx, `hx-trigger="not click"`?), or "changed", "delay", "throttle",
+  │ "once", "queue" — these are the trigger modifier keywords in 1.9. Let me search for `"delay"` or
+  │ `throttle`.
+  │
+  │ bash python3 - <<'EOF' src = open('/home/mac/Code/dashboard/static/vendor/htmx.mi…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "python3 - <<'EOF'\nsrc =
+  │       open('/home/mac/Code/dashboard/static/vendor/htmx.min.js').read()\nimport re\n# find
+  │       trigger keyword parsing region\nfor kw in ['\"delay\"', 'throttle', '\"changed\"',
+  │       'indexOf(\" ']:\n    i = src.find(kw)\n    print(kw, '->', i)\ni =
+  │       src.find('throttle')\nprint(src[i-3000:i+3000])\nEOF"
+  │     }
+  │   out
+  │     "delay" -> 15471
+  │     throttle -> 15797
+  │     "changed" -> 15363
+  │     indexOf("  -> -1
+  │     delete":De(r,n,i);return;default:var a=Fr(t);for(var o=0;o<a.length;o++){var s=a[o];try{var
+  │     l=s.handleSwap(e,r,n,i);if(l){if(typeof l.length!=="undefined"){for(var
+  │     u=0;u<l.length;u++){var
+  │     f=l[u];if(f.nodeType!==Node.TEXT_NODE&&f.nodeType!==Node.COMMENT_NODE){i.tasks.push(Oe(f))}}
+  │     }return}}catch(e){b(e)}}if(e==="innerHTML"){Ue(r,n,i)}else{Fe(Q.config.defaultSwapStyle,t,r,
+  │     n,i)}}}function Ve(e){if(e.indexOf("<title")>-1){var t=e.replace(H,"");var
+  │     r=t.match(q);if(r){return r[2]}}}function je(e,t,r,n,i,a){i.title=Ve(n);var
+  │     o=l(n);if(o){Ce(r,o,i);o=Be(r,o,a);Re(o);return Fe(e,r,t,o,i)}}function _e(e,t,r){var
+  │     n=e.getResponseHeader(t);if(n.indexOf("{")===0){var i=E(n);for(var a in
+  │     i){if(i.hasOwnProperty(a)){var o=i[a];if(!P(o)){o={value:o}}ce(r,a,o)}}}else{var
+  │     s=n.split(",");for(var l=0;l<s.length;l++){ce(r,s[l].trim(),[])}}}var ze=/\s/;var
+  │     x=/[\s,]/;var $e=/[_$a-zA-Z]/;var We=/[_$a-zA-Z0-9]/;var Ge=['"',"'","/"];var Je=/[^\s]/;var
+  │     Ze=/[{(]/;var Ke=/[})]/;function Ye(e){var t=[];var
+  │     r=0;while(r<e.length){if($e.exec(e.charAt(r))){var
+  │     n=r;while(We.exec(e.charAt(r+1))){r++}t.push(e.substr(n,r-n+1))}else
+  │     if(Ge.indexOf(e.charAt(r))!==-1){var i=e.charAt(r);var
+  │     n=r;r++;while(r<e.length&&e.charAt(r)!==i){if(e.charAt(r)==="\\"){r++}r++}t.push(e.substr(n,
+  │     r-n+1))}else{var a=e.charAt(r);t.push(a)}r++}return t}function Qe(e,t,r){return
+  │     $e.exec(e.charAt(0))&&e!=="true"&&e!=="false"&&e!=="this"&&e!==r&&t!=="."}function
+  │     et(e,t,r){if(t[0]==="["){t.shift();var n=1;var i=" return (function("+r+"){ return (";var
+  │     a=null;while(t.length>0){var
+  │     o=t[0];if(o==="]"){n--;if(n===0){if(a===null){i=i+"true"}t.shift();i+=")})";try{var
+  │     s=Tr(e,function(){return Function(i)()},function(){return true});s.source=i;return
+  │     s}catch(e){fe(re().body,"htmx:syntax:error",{error:e,source:i});return null}}}else
+  │     if(o==="["){n++}if(Qe(o,a,r)){i+="(("+r+"."+o+") ? ("+r+"."+o+") :
+  │     (window."+o+"))"}else{i=i+o}a=t.shift()}}}function y(e,t){var r="";while(e
+  │     … [4071 more chars]
+  │
+  │ tokens 44 in 453 out 38919 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:10:43 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ With this, I've confirmed htmx 1.9.12's trigger parser (`nt` function):
+  │
+  │ 1. **Custom event names work**: In the parser, any token `o` (like "click", "dash-poll") becomes
+  │ `{trigger: o}`, followed by optional modifiers
+  │ `changed/once/consume/delay/from/target/throttle/queue/root/threshold`. So
+  │ `hx-trigger="dash-poll"` is a valid DOM-event trigger.
+  │
+  │ 2. **The `from` syntax works**: `f==="from"&&i[0]===":"` → parses `from:#tab-overview` (note:
+  │ **the minified parser requires a colon**: `f==="from"&&i[0]===":"`). Interesting! In htmx
+  │ 1.9.12, the syntax is `from:#node` **with a colon**, not `from #node`. Wait, let me re-read:
+  │ `else if(f==="from"&&i[0]===":"){i.shift();...}` — yes, it requires `from:` followed by the node
+  │ selector. So in 1.9.x the syntax is `hx-trigger="dash-poll from:#tab-overview"`.
+  │
+  │ Hmm, wait, in the 2.x htmx docs the syntax is `hx-trigger="click from #parent"` (space). But in
+  │ 1.9.x it's `from:#parent`? Let me check again:
+  │ `if(f==="from"&&i[0]===":"){i.shift();if(Ze.test(i[0])){var c=tt(i)}else{var c=y(i,x);...}}`. So
+  │ `from:` must be followed by the selector (which may be a function expression starting with `{`
+  │ or `(` — `Ze=/[{(]/`). So in 1.9.12: `hx-trigger="my-event from:#id"`.
+  │
+  │ Wait, actually I need to re-verify: the token is split by whitespace, so `from:#tab-overview` is
+  │ a single token `from:#tab-overview`? No wait — the tokenizer `Ye` splits on whitespace and other
+  │ separators, but `from:#tab-overview` — `#` and `:` are… let me look at the tokenizer: it pushes
+  │ identifier chars `[_$a-zA-Z0-9]` runs, quoted strings, and otherwise single chars. So
+  │ `from:#tab-overview` gets tokenized as `from`, `:`, `#tab-overview`. So in the modifier loop:
+  │ `f="from"`, `i[0]===":"` ✓, shift the colon, then `c = y(i, x)` collects until whitespace/comma
+  │ → `#tab-overview`.
+  │
+  │ Then inside `ht` (addTriggerHandler): `if(s.from){t=Z(a,s.from)}else{t=[a]}` — `Z` is
+  │ `querySelectorExt`, which resolves `#tab-overview` from element `a`. So the listener gets
+  │ attached to the `from` node
+  │ … [28177 more chars]
+  │
+  │ I've confirmed everything I need. Key facts:
+  │
+  │ - **htmx 1.9.12** — its trigger parser (verified in `static/vendor/htmx.min.js`) supports
+  │ arbitrary DOM-event triggers plus the `from:` modifier (`hx-trigger="dash-poll from:#tab-x"`),
+  │ so a single event dispatched on a `<section>` can drive all polling elements inside it.
+  │ - htmx's built-in `every Ns` timers never pause for hidden elements — that's why all 6 tabs poll
+  │ from page load today.
+  │ - All 14 `hx-trigger` sites are identified (6 in `index.html`, 8 in fragments).
+  │ - Journal catch-up is bounded (200 entries/tick, DOM trimmed to 500 lines).
+  │
+  │ ## Plan
+  │
+  │ **Approach:** replace htmx's self-timed `every Ns` / `load` triggers with two custom events, and
+  │ drive them from JS scoped to the active tab:
+  │
+  │ - `dash-poll` — fired on the active section's `<section>` per tick (each periodic element in
+  │ that section listens via `from:#section`)
+  │ - `dash-activate` — fired once per tab activation, used by `#plugins` (one-shot list load,
+  │ deferred until the tab is first opened)
+  │
+  │ **Template changes** (trigger attribute only, no markup changes):
+  │
+  │ | File | Change |
+  │ |---|---|
+  │ | `templates/index.html:25,34,55,73,91` | `load, every Ns` → `dash-poll from:#tab-<name>` |
+  │ | `templates/index.html:95` | `load` → `dash-activate from:#tab-plugins` |
+  │ | `templates/{overview,disks,processes,services}.html:1` | `every Ns` → `dash-poll
+  │ from:#tab-<name>` |
+  │ | `templates/plugins/*_skeleton.html:2` (×4) | `every 5s` → `dash-poll from:#tab-plugins` |
+  │
+  │ **`static/js/app.js` changes:**
+  │
+  │ 1. Tab interval map: `{overview: 2000, disks: 2000, processes: 3000, journal: 5000, services:
+  │ 15000, plugins: 5000}`.
+  │ 2. `startTabPolling(name)`: clear any existing timer → fire `dash-activate` + `dash-poll` on the
+  │ section immediately (fresh data on every switch) → `setInterval` firing `dash-poll` at the tab's
+  │ interval → gate the charts' `/api/history` fetch loop on `name === "overview"` (replaces the
+  │ always-on `setInterval(pollHistory, 2000)` at app.js:130).
+  │ 3. `showTab(name)` calls `startTabPolling(name)`; initial call moves to the end of the IIFE
+  │ (after `initCharts()`) so the first chart fetch can't race chart creation. Single
+  │ `showTab(initial)` for both the default and localStorage-restored tab.
+  │ 4. No Python changes needed.
+  │
+  │ **Resulting behavior:**
+  │
+  │ - Page load fetches only the active tab; other tabs render empty until first visited.
+  │ - Switching tabs immediately refetches the target tab and stops the previous tab's timer —
+  │ exactly one interval runs at any time.
+  │ - Journal catches up on reactivation in ≤200-line batches (cursor was frozen while paused) — no
+  │ data loss.
+  │ - Services accordion (`openSvc` set) and process/sort/filter form state are unaffected; manual
+  │ htmx actions (filter submits, service buttons, plugin POSTs) keep working since only auto-poll
+  │ triggers change.
+  │
+  │ **Verification:** restart server per AGENTS.md, `compileall` + curl all endpoints for 200, then
+  │ in-browser via devtools: only active tab's requests fire; switching starts/stops timers; journal
+  │ catches up after being closed; plugins tab loads only when opened.
+  │
+  │ One optional addition before I finalize:
+  │
+  │ question Asked 1 question                                                            ok    13.0s
+  │   in
+  │     {
+  │       "questions": [
+  │         {
+  │           "question": "Should polling also pause when the whole browser tab is hidden (user
+  │           switched to another browser tab / minimized), resuming on return? It's ~8 extra lines
+  │           in app.js (visibilitychange listener).",
+  │           "header": "Page visibility",
+  │           "options": [
+  │             {
+  │               "label": "Yes, include it (Recommended)",
+  │               "description": "No polling at all while the page itself is hidden; resumes with a
+  │               fresh fetch when visible again."
+  │             },
+  │             {
+  │               "label": "No, keep it simple",
+  │               "description": "Only pause inactive dashboard tabs, as asked."
+  │             }
+  │           ]
+  │         }
+  │       ]
+  │     }
+  │   out User has answered your questions: "Should polling also pause when the whole browser tab is
+  │   hidden (user switched to another browser tab / minimized), resuming on return? It's ~8 extra
+  │   lines in app.js (visibilitychange listener)."="Yes, include it (Recommended)". You can now
+  │   continue with the user's answers in mind.
+  │
+  │ tokens 2176 in 9184 out 39416 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:12:40 • user
+  │
+  │ if it is helpful you are allowed to upgrade to htmx2
+
+
+  │ 2026-08-31 02:16:56 • assistant • Qwen3.8-27B-Think @plan
+  │
+  │ The user is saying, "You may upgrade to htmx2 if it helps." I need to evaluate whether upgrading
+  │ to htmx 2.x helps, or whether it's worth it.
+  │
+  │ Key considerations:
+  │
+  │ 1. **Does the htmx 2 upgrade help this task?**
+  │    - My plan already works with htmx 1.9.12: custom event triggers + the `from:` modifier are
+  │    fully supported in 1.9.12 (verified in the vendor source).
+  │    - In htmx 2.x, the `from` syntax is `from #node` (space-separated, no colon required...
+  │    actually, does 2.x also support `from:`? 2.x syntax: `hx-trigger="click from #el"`. The colon
+  │    form might be deprecated in 2.x, I think. Actually, in the htmx 2.0 docs: `hx-trigger="click
+  │    from #parent"` — the space form. I recall 2.x changed the syntax to space-separated.)
+  │    - So upgrading does not simplify the plan. The custom event + from approach works with
+  │    either.
+  │
+  │ 2. **Risks of the upgrade:**
+  │    - htmx 2.x has breaking changes: `hx-trigger` syntax changes (e.g., `from` syntax), removed
+  │    `hx:push`? Let me think about what actually changed in 2.0:
+  │      - `hx-vals`? Still exists.
+  │      - Breaking changes in 2.0 (from htmx changelog):
+  │        - `htmx.config` changes
+  │        - Event name changes? `htmx:beforeSwap` etc. are the same.
+  │        - Removed features: `htmx.sse`...
+  │        - `hx-trigger` syntax: `every 2s` is the same; `load` is the same; `from` is now `from
+  │        #node` (space); I think the old `from:#node` was kept? Not sure.
+  │        - `hx-include` is the same.
+  │        - `hx-swap` is the same.
+  │        - OOB swaps are the same.
+  │        - `hx-boost` is the same.
+  │        - In 2.x, `hx-trigger="load"` is... the same.
+  │        - One known change: `htmx:afterRequest` etc. are the same.
+  │        - In 2.0: "the `hx-trigger` attribute now uses a different syntax for `from`" — `from
+  │        #id` instead of `from:#id`.
+  │      - Also 2.x requires no polyfill; bundle size.
+  │    - Upgrading a vendored library means re-verifying that every htmx feature used in this
+  │    codebase works the same way: `hx-include`, `hx-vals`, `hx-confirm`, `hx-target`, `hx-swap` (
+  │ … [4804 more chars]
+  │
+  │ I looked into it — **the upgrade isn't helpful here, so I'd keep htmx 1.9.12.**
+  │
+  │ - htmx 2.x adds no per-element polling pause API; my design (custom `dash-poll`/`dash-activate`
+  │ events + `from:` binding to the section) works identically on both versions.
+  │ - I already verified in `static/vendor/htmx.min.js` that the installed 1.9.12 parses arbitrary
+  │ event names and the `from:` modifier — the only 2.x difference would be cosmetic syntax (`from
+  │ #el` vs `from:#el`).
+  │ - Upgrading means re-verifying every htmx feature used across 15 templates + `app.js`
+  │ (`hx-include`, `hx-vals`, `hx-confirm`, `beforeend` swap, `htmx.ajax`, OOB-free swaps) for zero
+  │ benefit to this task.
+  │
+  │ ## Final plan
+  │
+  │ **Templates** — swap auto-poll triggers for custom events (14 sites):
+  │ - `templates/index.html:25,34,55,73,91` → `hx-trigger="dash-poll from:#tab-<name>"`
+  │ - `templates/index.html:95` → `hx-trigger="dash-activate from:#tab-plugins"` (one-shot, deferred
+  │ to first visit)
+  │ - `templates/{overview,disks,processes,services}.html:1` → `dash-poll from:#tab-<name>`
+  │ - `templates/plugins/*_skeleton.html:2` (×4) → `dash-poll from:#tab-plugins`
+  │
+  │ **`static/js/app.js`**:
+  │ 1. `TAB_INTERVALS = {overview: 2000, disks: 2000, processes: 3000, journal: 5000, services:
+  │ 15000, plugins: 5000}`
+  │ 2. `startTabPolling(name)`: clear timers → fire `dash-activate` + `dash-poll` on `#tab-<name>`
+  │ (fresh data on every switch) → `setInterval` for that tab → `setHistoryPolling(name ===
+  │ "overview")` gates the charts' `/api/history` loop (replaces always-on `setInterval` at
+  │ app.js:130)
+  │ 3. `showTab()` calls `startTabPolling()`; single initial `showTab(initial)` moved to the end of
+  │ the IIFE (after `initCharts()`) to avoid a chart-fetch race; handles both default and
+  │ localStorage-restored tab
+  │ 4. **Page-visibility pause** (per your answer): `visibilitychange` listener — hidden → clear
+  │ both timers; visible → `startTabPolling(activeTab)` (immediate fresh fetch + timers restart)
+  │
+  │ **Behavior:** load fetches only the active tab; hidden tabs load lazily on first visit; one
+  │ timer at a time; journal catches up in ≤200-line batches on return (no data loss); services
+  │ accordion + form state + all manual actions unaffected. No Python changes.
+  │
+  │ **Verify:** restart per AGENTS.md → `compileall` + curl all endpoints → browser devtools: only
+  │ active tab polls, timers start/stop on switch, journal catch-up, plugins load on open, no
+  │ requests while page hidden.
+  │
+  │ Ready to execute when you are.
+  │
+  │ tokens 41666 in 2610 out 9211 cached 0 written $0.0000 stop
+
+
+  │ 2026-08-31 02:20:17 • user
+  │
+  │ ok let's try
+
+
+  │ 2026-08-31 02:20:17 • assistant • Qwen3.8-27B-Think
+  │
+  │ Let's execute the plan. Steps:
+  │
+  │ 1. Read the files to be modified (index.html, the 8 fragment templates, app.js) — I already have
+  │ their contents from exploration, but I have to Read them before editing (tool requirement).
+  │ Let's read them in parallel.
+  │ 2. Edit the triggers in the templates.
+  │ 3. Rewrite the tab/chart polling portion of app.js.
+  │ 4. Verification: compileall, restart the server, curl the endpoints, and grep for Traceback.
+  │
+  │ Let's set up the TODO list and read the files.
+  │
+  │ todowrite 4 todos                                                                    ok     0.0s
+  │   in
+  │     {
+  │       "todos": [
+  │         {
+  │           "content": "Update hx-trigger in index.html (6 sites)",
+  │           "status": "in_progress",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update hx-trigger in 8 fragment templates",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Rework app.js: tab-scoped polling + charts gating + visibility pause",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Restart server and verify endpoints + no tracebacks",
+  │           "status": "pending",
+  │           "priority": "high"
+  │         }
+  │       ]
+  │     }
+  │   out
+  │     [
+  │       {
+  │         "content": "Update hx-trigger in index.html (6 sites)",
+  │         "status": "in_progress",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update hx-trigger in 8 fragment templates",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Rework app.js: tab-scoped polling + charts gating + visibility pause",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Restart server and verify endpoints + no tracebacks",
+  │         "status": "pending",
+  │         "priority": "high"
+  │       }
+  │     ]
+  │ 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:
+  │     … [2964 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
+  │     … [7354 more chars]
+  │
+  │ tokens 53278 in 323 out 0 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:22:06 • assistant • Qwen3.8-27B-Think
+  │
+  │ Now going to edit index.html (6 locations), then the 8 fragment templates (I need to read them
+  │ before editing — the tool requires that a Read has been performed before an edit). Let me first
+  │ do the index.html edit, and in parallel read the fragment templates.
+  │
+  │ Actually, I can do the index.html edit right now (already read). Then read the 8 fragment files
+  │ in parallel, and edit them.
+  │
+  │ index.html edits:
+  │ - L25: `hx-trigger="load, every 2s"` → `hx-trigger="dash-poll from:#tab-overview"` — note that
+  │ `load, every 2s` appears twice (L25 and L34). Need to disambiguate with context. L25: `<div
+  │ id="overview" class="panel" hx-get="/api/overview" hx-trigger="load, every 2s"
+  │ hx-swap="outerHTML"></div>`; L34: `<div id="disks" class="panel" hx-get="/api/disks"
+  │ hx-trigger="load, every 2s" hx-swap="outerHTML"></div>`. Since the hx-get differs, each is
+  │ unique.
+  │
+  │ Let me make 6 separate edits, each with enough context to be unique.
+  │
+  │ Now the edits. First `templates/index.html` (6 sites):
+  │
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/overview\" hx-trigger=\"load, every 2s\"
+  │       hx-swap=\"outerHTML\"",
+  │       "newString": "hx-get=\"/api/overview\" hx-trigger=\"dash-poll from:#tab-overview\"
+  │       hx-swap=\"outerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/disks\" hx-trigger=\"load, every 2s\" hx-swap=\"outerHTML\"",
+  │       "newString": "hx-get=\"/api/disks\" hx-trigger=\"dash-poll from:#tab-disks\"
+  │       hx-swap=\"outerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/processes\" hx-trigger=\"load, every 3s\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#proc-controls\"",
+  │       "newString": "hx-get=\"/api/processes\" hx-trigger=\"dash-poll from:#tab-processes\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#proc-controls\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/journal\" hx-trigger=\"load, every 5s\"
+  │       hx-swap=\"beforeend\"",
+  │       "newString": "hx-get=\"/api/journal\" hx-trigger=\"dash-poll from:#tab-journal\"
+  │       hx-swap=\"beforeend\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/services\" hx-trigger=\"load, every 15s\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#svc-filters\"",
+  │       "newString": "hx-get=\"/api/services\" hx-trigger=\"dash-poll from:#tab-services\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#svc-filters\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/index.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/index.html",
+  │       "oldString": "hx-get=\"/api/plugins\" hx-trigger=\"load\" hx-swap=\"outerHTML\"",
+  │       "newString": "hx-get=\"/api/plugins\" hx-trigger=\"dash-activate from:#tab-plugins\"
+  │       hx-swap=\"outerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ read /home/mac/Code/dashboard/templates/overview.html [output truncated]             ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/overview.html",
+  │       "limit": 3
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/overview.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="every 2s"
+  │     hx-swap="outerHTML">
+  │     2:   {% macro bar(pct) %}{% if pct is not none %}<div class="bar"><div class="bar-fill{% if
+  │     pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct }}%"></div></div>{%
+  │     endif %}{% endmacro %}
+  │     3:   {% macro barrow(label, pct, cls) %}{% if pct is not none %}<div class="barrow"><span
+  │     class="barrow-label">{{ label }}</span><div class="bar"><div class="bar-fill{% if cls %} {{
+  │     cls }}{% endif %}{% if pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{
+  │     pct }}%"></div></div></div>{% endif %}{% endmacro %}
+  │
+  │     (Showing lines 1-3 of 71. Use offset=4 to continue.)
+  │     </content>
+  │   truncated 797 chars shown, the rest was not kept
+  │ read /home/mac/Code/dashboard/templates/disks.html [output truncated]                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/disks.html",
+  │       "limit": 3
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/disks.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="every 2s"
+  │     hx-swap="outerHTML">
+  │     2:   <h2>Filesystems</h2>
+  │     3:   <div class="part-list">
+  │
+  │     (Showing lines 1-3 of 50. Use offset=4 to continue.)
+  │     </content>
+  │   truncated 302 chars shown, the rest was not kept
+  │ read /home/mac/Code/dashboard/templates/processes.html [output truncated]            ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/processes.html",
+  │       "limit": 3
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/processes.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="every 3s"
+  │     hx-swap="outerHTML" hx-include="#proc-controls">
+  │     2:   <div class="muted small">showing {{ procs | length }} of {{ total }} processes</div>
+  │     3:   <div class="table-wrap">
+  │
+  │     (Showing lines 1-3 of 44. Use offset=4 to continue.)
+  │     </content>
+  │   truncated 412 chars shown, the rest was not kept
+  │ read /home/mac/Code/dashboard/templates/services.html [output truncated]             ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/services.html",
+  │       "limit": 3
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/services.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="services" class="panel" hx-get="/api/services" hx-trigger="every 15s"
+  │     hx-swap="outerHTML" hx-include="#svc-filters">
+  │     2:   {% if error %}<div class="alert">{{ error }}</div>{% endif %}
+  │     3:   <div class="muted small">system: {{ state }} &middot; {{ units | length }} units</div>
+  │
+  │     (Showing lines 1-3 of 55. Use offset=4 to continue.)
+  │     </content>
+  │   truncated 442 chars shown, the rest was not kept
+  │ read /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="llama">
+  │     2:   <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/llamacpp_state.html" %}
+  │     4:   </div>
+  │     5:   {% if reachable %}
+  │     6:   <h4>Available models</h4>
+  │     7:   {% if available %}
+  │     8:   <div class="llama-load">
+  │     9:     <select id="llama-model-pick" name="model">
+  │     10:       {% for m in available %}
+  │     11:       <option value="{{ m.id }}">{{ m.id }}{% if m.failed %} (failed, exit {{
+  │     m.exit_code }}){% endif %}</option>
+  │     12:       {% endfor %}
+  │     13:     </select>
+  │     14:     <button class="btn" hx-post="/api/plugins/llamacpp/load"
+  │     hx-include="#llama-model-pick" hx-target="closest .plugin-body"
+  │     hx-swap="innerHTML">load</button>
+  │     15:   </div>
+  │     16:   {% else %}
+  │     17:   <div class="muted small">no unloaded models (is --models-dir set on the server?)</div>
+  │     18:   {% endif %}
+  │     19:
+  │     20:   <div class="actions">
+  │     21:     <button class="btn" hx-post="/api/plugins/llamacpp/rescan" hx-target="closest
+  │     .plugin-body" hx-swap="innerHTML">rescan models</button>
+  │     22:   </div>
+  │     23:   {% endif %}
+  │     24: </div>
+  │
+  │     (End of file - total 24 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html                  ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="sleep">
+  │     2:   <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/sleep_state.html" %}
+  │     4:   </div>
+  │     5: </div>
+  │
+  │     (End of file - total 5 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/lact_skeleton.html                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/lact_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/lact_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="lact">
+  │     2:   <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/lact_state.html" %}
+  │     4:   </div>
+  │     5:   {% if gpus and not error %}
+  │     6:   {% for g in gpus %}
+  │     7:   <div class="lact-load">
+  │     8:     <select id="lact-pick-{{ g.id }}" name="profile">
+  │     9:       {% for p in g.profiles %}
+  │     10:       <option value="{{ p }}" {{ "selected" if p == g.active }}>{{ p }}{% if p ==
+  │     g.active %} (active){% endif %}</option>
+  │     11:       {% else %}
+  │     12:       <option value="" disabled selected>no profiles</option>
+  │     13:       {% endfor %}
+  │     14:     </select>
+  │     15:     <span class="actions">
+  │     16:       <button class="btn" hx-post="/api/plugins/lact/set" hx-vals='{"gpu_id":"{{ g.id
+  │     }}"}' hx-include="#lact-pick-{{ g.id }}" hx-target="closest .plugin-body"
+  │     hx-swap="innerHTML">set</button>
+  │     17:       <button class="btn" hx-post="/api/plugins/lact/reload" hx-vals='{"gpu_id":"{{ g.id
+  │     }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML">reload</button>
+  │     18:     </span>
+  │     19:   </div>
+  │     20:   {% endfor %}
+  │     21:   {% endif %}
+  │     22: </div>
+  │
+  │     (End of file - total 22 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="sessions">
+  │     2:   <div id="sessions-state" hx-get="/api/plugins/sessions/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/sessions_state.html" %}
+  │     4:   </div>
+  │     5: </div>
+  │
+  │     (End of file - total 5 lines)
+  │     </content>
+  │
+  │ tokens 5120 in 1261 out 53600 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) 9dd51208
+
+
+  │ 2026-08-31 02:23:01 • assistant • Qwen3.8-27B-Think
+  │
+  │ index.html done. Next up are the 8 fragment templates:
+  │
+  │ Now the 8 fragment templates:
+  │
+  │ edit /home/mac/Code/dashboard/templates/overview.html                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/overview.html",
+  │       "oldString": "hx-get=\"/api/overview\" hx-trigger=\"every 2s\" hx-swap=\"outerHTML\"",
+  │       "newString": "hx-get=\"/api/overview\" hx-trigger=\"dash-poll from:#tab-overview\"
+  │       hx-swap=\"outerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/disks.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/disks.html",
+  │       "oldString": "hx-get=\"/api/disks\" hx-trigger=\"every 2s\" hx-swap=\"outerHTML\"",
+  │       "newString": "hx-get=\"/api/disks\" hx-trigger=\"dash-poll from:#tab-disks\"
+  │       hx-swap=\"outerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/processes.html                               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/processes.html",
+  │       "oldString": "hx-get=\"/api/processes\" hx-trigger=\"every 3s\" hx-swap=\"outerHTML\"
+  │       hx-include=\"#proc-controls\"",
+  │       "newString": "hx-get=\"/api/processes\" hx-trigger=\"dash-poll from:#tab-processes\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#proc-controls\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/services.html                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/services.html",
+  │       "oldString": "hx-get=\"/api/services\" hx-trigger=\"every 15s\" hx-swap=\"outerHTML\"
+  │       hx-include=\"#svc-filters\"",
+  │       "newString": "hx-get=\"/api/services\" hx-trigger=\"dash-poll from:#tab-services\"
+  │       hx-swap=\"outerHTML\" hx-include=\"#svc-filters\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html",
+  │       "oldString": "hx-get=\"/api/plugins/llamacpp/state\" hx-trigger=\"every 5s\"
+  │       hx-swap=\"innerHTML\"",
+  │       "newString": "hx-get=\"/api/plugins/llamacpp/state\" hx-trigger=\"dash-poll
+  │       from:#tab-plugins\" hx-swap=\"innerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html                  ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html",
+  │       "oldString": "hx-get=\"/api/plugins/sleep/state\" hx-trigger=\"every 5s\"
+  │       hx-swap=\"innerHTML\"",
+  │       "newString": "hx-get=\"/api/plugins/sleep/state\" hx-trigger=\"dash-poll
+  │       from:#tab-plugins\" hx-swap=\"innerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/plugins/lact_skeleton.html                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/lact_skeleton.html",
+  │       "oldString": "hx-get=\"/api/plugins/lact/state\" hx-trigger=\"every 5s\"
+  │       hx-swap=\"innerHTML\"",
+  │       "newString": "hx-get=\"/api/plugins/lact/state\" hx-trigger=\"dash-poll
+  │       from:#tab-plugins\" hx-swap=\"innerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html",
+  │       "oldString": "hx-get=\"/api/plugins/sessions/state\" hx-trigger=\"every 5s\"
+  │       hx-swap=\"innerHTML\"",
+  │       "newString": "hx-get=\"/api/plugins/sessions/state\" hx-trigger=\"dash-poll
+  │       from:#tab-plugins\" hx-swap=\"innerHTML\""
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 1869 in 913 out 59980 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 8 file(s) 9af59a2a
+
+
+  │ 2026-08-31 02:23:36 • assistant • Qwen3.8-27B-Think
+  │
+  │ All template edits are complete. Next is app.js. Changes:
+  │
+  │ 1. Replace the tabs section (lines 4-19) with a new structure:
+  │    - Constants for tabBtns/sections
+  │    - TAB_INTERVALS map
+  │    - Polling state (pollTimer, histTimer, activeTab)
+  │    - fireTabEvent, setHistoryPolling, startTabPolling, stopPolling
+  │    - showTab (with startTabPolling)
+  │    - Click listener
+  │    - (Remove the saved-restore block here; move the initial showTab to the end of the IIFE)
+  │
+  │ 2. Replace lines 128-130 (`initCharts(); pollHistory(); setInterval(...)`) with just
+  │ `initCharts();`
+  │
+  │ 3. At the end of the IIFE (before the closing `})();`), add the following:
+  │    - visibilitychange listener
+  │    - Initial showTab
+  │
+  │ Wait, the ordering: `showTab(initial)` has to run after `initCharts()` (line 128). Put the
+  │ initialization block at the very end of the IIFE.
+  │
+  │ Now, let me think through the JS carefully:
+  │
+  │ ```js
+  │   // ---------- tabs ----------
+  │   const tabBtns = document.querySelectorAll(".tab-btn");
+  │   const sections = document.querySelectorAll(".tab");
+  │
+  │   // Polling interval (ms) for each tab
+  │   const TAB_INTERVALS = { overview: 2000, disks: 2000, processes: 3000, journal: 5000, services:
+  │   15000, plugins: 5000 };
+  │
+  │   let activeTab = null;
+  │   let pollTimer = null;
+  │   let histTimer = null;
+  │
+  │   function fireTabEvent(type, name) {
+  │     const sec = document.getElementById("tab-" + name);
+  │     if (sec) htmx.trigger(sec, type);
+  │   }
+  │
+  │   function setHistoryPolling(on) {
+  │     if (on && !histTimer) {
+  │       pollHistory();
+  │       histTimer = setInterval(pollHistory, 2000);
+  │     } else if (!on && histTimer) {
+  │       clearInterval(histTimer);
+  │       histTimer = null;
+  │     }
+  │   }
+  │
+  │   function stopPolling() {
+  │     if (pollTimer) {
+  │       clearInterval(pollTimer);
+  │       pollTimer = null;
+  │     }
+  │     setHistoryPolling(false);
+  │   }
+  │
+  │   // Refresh the tab immediately and keep it polling at its own interval
+  │   function startTabPolling(name) {
+  │     stopPolling();
+  │     activeTab = name;
+  │     fireTabEvent("dash-activate", name);
+  │     fireTabEvent("dash-poll", name);
+  │
+  │ … [2445 more chars]
+  │
+  │ I've updated all 14 template sites. Before writing the JS, let me verify the htmx 1.9.12
+  │ `htmx.trigger` implementation (the public `ce` function) to confirm that it dispatches a
+  │ standard DOM event that the `from:` listener will catch:
+  │
+  │ bash python3 - <<'EOF' src = open('/home/mac/Code/dashboard/static/vendor/htmx.mi…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "python3 - <<'EOF'\nsrc =
+  │       open('/home/mac/Code/dashboard/static/vendor/htmx.min.js').read()\ni = src.find('function
+  │       ce(')\nif i < 0:\n    # try arrow/var form\n    for m in ['ce=function', 'var ce',
+  │       'function ce']:\n        i = src.find(m)\n        print(m, '->', i)\nelse:\n
+  │       print(src[i:i+400])\nEOF"
+  │     }
+  │   out function ce(e,t,r){e=p(e);if(r==null){r={}}r["elt"]=e;var
+  │   n=Wt(t,r);if(Q.logger&&!Gt(t)){Q.logger(e,t,r)}if(r.error){b(r.error);ce(e,"htmx:error",{error
+  │   Info:r})}var i=e.dispatchEvent(n);var a=$t(t);if(i&&a!==t){var
+  │   o=Wt(a,n.detail);i=i&&e.dispatchEvent(o)}R(e,function(e){i=i&&(e.onEvent(t,n)!==false&&!n.defa
+  │   ultPrevented)});return i}var Jt=location.pathname+location.search;function Zt(){var e=re().
+  │
+  │ tokens 82 in 1467 out 62762 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:24:30 • assistant • Qwen3.8-27B-Think
+  │
+  │ `ce(e,t,r)`: `e=p(e)` (normalization, probably ensuring it's an element), `r["elt"]=e`,
+  │ `n=Wt(t,r)` — Wt creates an event (CustomEvent with detail r), then `e.dispatchEvent(n)` ✓. So
+  │ `htmx.trigger(sec, "dash-poll")` dispatches a `CustomEvent("dash-poll", {detail: {...}})` on the
+  │ section element. The `from:` listener attached to the same element fires. ✓
+  │
+  │ Wait — one more thing to check: `Wt(t, r)` — creates the event. Is it `bubbles: true`? Doesn't
+  │ matter, the listener is on the same node. ✓
+  │
+  │ Also `$t(t)` — "alias" event? For example, in the case of `htmx:beforeSwap`… unrelated.
+  │
+  │ Alright, let's write the changes to app.js. Three edits:
+  │
+  │ **Edit 1**: Replace lines 4–19 (tab section + restore block) with the new tab + polling
+  │ machinery.
+  │
+  │ Old:
+  │ ```js
+  │   // ---------- tabs ----------
+  │   const tabBtns = document.querySelectorAll(".tab-btn");
+  │   const sections = document.querySelectorAll(".tab");
+  │
+  │   function showTab(name) {
+  │     tabBtns.forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
+  │     sections.forEach((s) => s.classList.toggle("hidden", s.id !== "tab-" + name));
+  │     try {
+  │       localStorage.setItem("dash.tab", name);
+  │     } catch (e) {}
+  │   }
+  │   tabBtns.forEach((b) => b.addEventListener("click", () => showTab(b.dataset.tab)));
+  │   try {
+  │     const saved = localStorage.getItem("dash.tab");
+  │     if (saved && document.getElementById("tab-" + saved)) showTab(saved);
+  │   } catch (e) {}
+  │ ```
+  │
+  │ New:
+  │ ```js
+  │   // ---------- tabs ----------
+  │   const tabBtns = document.querySelectorAll(".tab-btn");
+  │   const sections = document.querySelectorAll(".tab");
+  │
+  │   // Per-tab polling interval (ms). Only the active tab polls: htmx's
+  │   // "every" timers can't pause per-element, so polling is driven by JS
+  │   // dispatching "dash-poll" on the active section (see hx-trigger
+  │   // "dash-poll from:#tab-<name>" in the templates).
+  │   const TAB_INTERVALS = { overview: 2000, disks: 2000, processes: 3000, journal: 5000, services:
+  │   15000, plugins: 5000 };
+  │
+  │   let activeTab = null;
+  │   let pollTimer = null;
+  │
+  │ … [7753 more chars]
+  │
+  │ `htmx.trigger` dispatches a real DOM event on the element ✓. However, one thing needs to be
+  │ verified: how htmx 1.9.12 resolves the `from:` node — if it uses `element.querySelector`, then
+  │ ancestor IDs like `#tab-overview` won't be found. Let's check the internal implementation:
+  │
+  │ bash python3 - <<'EOF' src = open('/home/mac/Code/dashboard/static/vendor/htmx.mi…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "python3 - <<'EOF'\nsrc =
+  │       open('/home/mac/Code/dashboard/static/vendor/htmx.min.js').read()\ni = src.find('function
+  │       Z(')\nprint(src[i:i+700] if i >= 0 else 'Z( not found as function def')\nprint('---')\n#
+  │       also find where Z(a,s.from) is used\nj = src.find('s.from')\nprint(src[j-300:j+300])\nEOF"
+  │     }
+  │   out
+  │     function Z(e,t){if(t.indexOf("closest ")===0){return[v(e,J(t.substr(8)))]}else
+  │     if(t.indexOf("find ")===0){return[C(e,J(t.substr(5)))]}else
+  │     if(t==="next"){return[e.nextElementSibling]}else if(t.indexOf("next
+  │     ")===0){return[K(e,J(t.substr(5)))]}else
+  │     if(t==="previous"){return[e.previousElementSibling]}else if(t.indexOf("previous
+  │     ")===0){return[Y(e,J(t.substr(9)))]}else if(t==="document"){return[document]}else
+  │     if(t==="window"){return[window]}else if(t==="body"){return[document.body]}else{return
+  │     re().querySelectorAll(J(t))}}var K=function(e,t){var r=re().querySelectorAll(t);for(var
+  │     n=0;n<r.length;n++){var
+  │     i=r[n];if(i.compareDocumentPosition(e)===Node.DOCUMENT_POSITION_PRECEDING){return i}}};var Y
+  │     ---
+  │     {return ae(e).boosted&&e.tagName==="A"&&t.type==="click"&&(t.ctrlKey||t.metaKey)}function
+  │     ct(e,t,r){var n=e.eventFilter;if(n){try{return
+  │     n.call(t,r)!==true}catch(e){fe(re().body,"htmx:eventFilter:error",{error:e,source:n.source})
+  │     ;return true}}return false}function ht(a,o,e,s,l){var u=ae(a);var
+  │     t;if(s.from){t=Z(a,s.from)}else{t=[a]}if(s.changed){t.forEach(function(e){var
+  │     t=ae(e);t.lastValue=e.value})}oe(t,function(n){var
+  │     i=function(e){if(!se(a)){n.removeEventListener(s.trigger,i);return}if(ft(a,e)){return}if(l||
+  │     ut(e,a)){e.preventDefault()}if(ct(s,a,e)){return}var t=ae(e);t.triggerSpec=s;if(t.ha
+  │
+  │ tokens 157 in 2987 out 64312 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:26:26 • assistant • Qwen3.8-27B-Think
+  │
+  │ Confirmed: `function Z(e,t)` — for plain selectors (ones that don't start with
+  │ closest/find/next/previous and aren't document/window/body), it executes
+  │ `re().querySelectorAll(J(t))` — a **document-global** `querySelectorAll`, **not**
+  │ `e.querySelector(t)`. So `from:#tab-overview` resolves
+  │ `document.querySelectorAll("#tab-overview")` → the section itself, even though it's an ancestor
+  │ of the polling element.
+  │
+  │ In other words, my design works with the installed htmx 1.9.12 as-is: `hx-trigger="dash-poll
+  │ from:#tab-overview"` attaches a `dash-poll` listener to the section, and `htmx.trigger(section,
+  │ "dash-poll")` fires it.
+  │
+  │ Now I'll write the changes to app.js.
+  │
+  │ Edit 1: tabs section (lines 4-19).
+  │ Edit 2: lines 128-130 (chart bootstrap).
+  │ Edit 3: at the end of the IIFE, before `})();`.
+  │
+  │ Confirmed — `Z()` falls through to `document.querySelectorAll(selector)` (document-global, not
+  │ element-scoped), so ancestor IDs like `#tab-overview` resolve correctly. This design works with
+  │ the installed htmx 1.9.12.
+  │
+  │ Next up is rebuilding `app.js`:
+  │
+  │ edit /home/mac/Code/dashboard/static/js/app.js                                       ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/static/js/app.js",
+  │       "oldString": "  // ---------- tabs ----------\n  const tabBtns =
+  │       document.querySelectorAll(\".tab-btn\");\n  const sections =
+  │       document.querySelectorAll(\".tab\");\n\n  function showTab(name) {\n
+  │       tabBtns.forEach((b) => b.classList.toggle(\"active\", b.dataset.tab === name));\n
+  │       sections.forEach((s) => s.classList.toggle(\"hidden\", s.id !== \"tab-\" + name));\n
+  │       try {\n      localStorage.setItem(\"dash.tab\", name);\n    } catch (e) {}\n  }\n
+  │       tabBtns.forEach((b) => b.addEventListener(\"click\", () => showTab(b.dataset.tab)));\n
+  │       try {\n    const saved = localStorage.getItem(\"dash.tab\");\n    if (saved &&
+  │       document.getElementById(\"tab-\" + saved)) showTab(saved);\n  } catch (e) {}",
+  │       "newString": "  // ---------- tabs ----------\n  const tabBtns =
+  │       document.querySelectorAll(\".tab-btn\");\n  const sections =
+  │       document.querySelectorAll(\".tab\");\n\n  // per-tab poll interval (ms); htmx \"every\"
+  │       timers cannot pause per\n  // element, so only the active tab polls: JS dispatches
+  │       \"dash-poll\" on\n  // its section, where every polling element listens via\n  //
+  │       hx-trigger=\"dash-poll from:#tab-<name>\"\n  const TAB_INTERVALS = { overview: 2000,
+  │       disks: 2000, processes: 3000, journal: 5000, services: 15000, plugins: 5000 };\n\n  let
+  │       activeTab = null;\n  let pollTimer = null;\n  let histTimer = null;\n\n  function
+  │       fireTabEvent(type, name) {\n    const sec = document.getElementById(\"tab-\" + name);\n
+  │       if (sec) htmx.trigger(sec, type);\n  }\n\n  function setHistoryPolling(on) {\n    if (on
+  │       && !histTimer) {\n      pollHistory();\n      histTimer = setInterval(pollHistory,
+  │       2000);\n    } else if (!on && histTimer) {\n      clearInterval(histTimer);\n
+  │       histTimer = null;\n    }\n  }\n\n  function stopPolling() {\n    if (pollTimer) {\n
+  │       clearInterval(pollTimer);\n      pollTimer = null;\n    }\n    setHistoryPolling(false);\n
+  │       }\n\n  function startTabPolling(name) {\n    stopPolling();\n    activeTab
+  │     … [802 more chars]
+  │   out Edit applied successfully.
+  │ edit /home/mac/Code/dashboard/static/js/app.js                                       ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/static/js/app.js",
+  │       "oldString": "  initCharts();\n  pollHistory();\n  setInterval(pollHistory, 2000);",
+  │       "newString": "  initCharts();"
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 414 in 1169 out 67457 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) 344b8b33
+
+
+  │ 2026-08-31 02:27:07 • assistant • Qwen3.8-27B-Think
+  │
+  │ Next, I'll add a startup block at the end of the IIFE (visibilitychange + initial showTab). End
+  │ of the file:
+  │
+  │ ```js
+  │   document.body.addEventListener("htmx:afterSwap", (e) => {
+  │     if (e.target.id !== "services" || !openSvc.size) return;
+  │     for (const row of e.target.querySelectorAll("tr.svc-row")) {
+  │       const unit = row.dataset.unit;
+  │       if (!openSvc.has(unit)) continue;
+  │       const detailRow = row.nextElementSibling;
+  │       if (!detailRow || !detailRow.classList.contains("svc-detail-row")) continue;
+  │       row.classList.add("open");
+  │       detailRow.hidden = false;
+  │       loadSvcDetail(unit, detailRow.querySelector(".svc-detail"));
+  │     }
+  │   });
+  │ })();
+  │ ```
+  │
+  │ Now the startup block at the end of the IIFE (page-visibility pause + initial tab):
+  │
+  │ edit /home/mac/Code/dashboard/static/js/app.js                                       ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/static/js/app.js",
+  │       "oldString": "      row.classList.add(\"open\");\n      detailRow.hidden = false;\n
+  │       loadSvcDetail(unit, detailRow.querySelector(\".svc-detail\"));\n    }\n  });\n})();",
+  │       "newString": "      row.classList.add(\"open\");\n      detailRow.hidden = false;\n
+  │       loadSvcDetail(unit, detailRow.querySelector(\".svc-detail\"));\n    }\n  });\n\n  //
+  │       ---------- startup ----------\n  // pause all polling while this browser tab is hidden,
+  │       resume with a\n  // fresh fetch when it becomes visible again\n
+  │       document.addEventListener(\"visibilitychange\", () => {\n    if (document.hidden)
+  │       stopPolling();\n    else if (activeTab) startTabPolling(activeTab);\n  });\n\n  let
+  │       initial = \"overview\";\n  try {\n    const saved = localStorage.getItem(\"dash.tab\");\n
+  │       if (saved && document.getElementById(\"tab-\" + saved)) initial = saved;\n  } catch (e)
+  │       {}\n  showTab(initial);\n})();"
+  │     }
+  │   out Edit applied successfully.
+  │
+  │ tokens 29 in 455 out 69039 cached 0 written $0.0000 tool-calls
+  │
+  │ patch 1 file(s) d80686b7
+
+
+  │ 2026-08-31 02:27:23 • assistant • Qwen3.8-27B-Think
+  │
+  │ Wait a sec—there's a subtle ordering bug: `showTab(initial)` at the end of the IIFE calls
+  │ `startTabPolling` → `setHistoryPolling(true)` (in the overview case) → `pollHistory()` →
+  │ `.then(updateCharts)` —— async, so the chart needs to be initialized by that point.
+  │ `initCharts()` runs before the startup block (line 128, before the journal/sorting/accordion
+  │ sections). So by the time the fetch resolves, the chart is initialized. ✓
+  │
+  │ But wait—`pollHistory` is a function declaration defined in the chart section (hoisted anyway).
+  │ ✓
+  │
+  │ Another check: `showTab` at the end of the file—`showTab` is a function declaration in the tab
+  │ section (hoisted), and `tabBtns`/`sections` are const—already initialized by the time the end
+  │ runs. ✓
+  │
+  │ `stopPolling`/`startTabPolling` are function declarations, hoisted ✓.
+  │
+  │ Alright, let me re-read the final app.js and verify that the whole file is consistent.
+  │
+  │ Let me verify the full file is coherent:
+  │
+  │ 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:   // per-tab poll interval (ms); htmx "every" timers cannot pause per
+  │     9:   // element, so only the active tab polls: JS dispatches "dash-poll" on
+  │     10:   // its section, where every polling element listens via
+  │     11:   // hx-trigger="dash-poll from:#tab-<name>"
+  │     12:   const TAB_INTERVALS = { overview: 2000, disks: 2000, processes: 3000, journal: 5000,
+  │     services: 15000, plugins: 5000 };
+  │     13:
+  │     14:   let activeTab = null;
+  │     15:   let pollTimer = null;
+  │     16:   let histTimer = null;
+  │     17:
+  │     18:   function fireTabEvent(type, name) {
+  │     19:     const sec = document.getElementById("tab-" + name);
+  │     20:     if (sec) htmx.trigger(sec, type);
+  │     21:   }
+  │     22:
+  │     23:   function setHistoryPolling(on) {
+  │     24:     if (on && !histTimer) {
+  │     25:       pollHistory();
+  │     26:       histTimer = setInterval(pollHistory, 2000);
+  │     27:     } else if (!on && histTimer) {
+  │     28:       clearInterval(histTimer);
+  │     29:       histTimer = null;
+  │     30:     }
+  │     31:   }
+  │     32:
+  │     33:   function stopPolling() {
+  │     34:     if (pollTimer) {
+  │     35:       clearInterval(pollTimer);
+  │     36:       pollTimer = null;
+  │     37:     }
+  │     38:     setHistoryPolling(false);
+  │     39:   }
+  │     40:
+  │     41:   function startTabPolling(name) {
+  │     42:     stopPolling();
+  │     43:     activeTab = name;
+  │     44:     // "dash-activate" is the one-shot trigger (plugins list), "dash-poll"
+  │     45:     // the recurring one; firing both refreshes the tab immediately
+  │     46:     fireTabEvent("dash-activate", name);
+  │     47:     fireTabEvent("dash-poll", name);
+  │     48:     pollTimer = setInterval(() => fireTabEvent("dash-poll", name), TAB_INTERVALS[name]
+  │     || 5000);
+  │     49:     setHistoryPolling(name === "overview");
+  │     50:   }
+  │     51:
+  │     52:   function showTab(name) {
+  │     53:     tabBtns.forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
+  │     54:     sections.forEach((s
+  │     … [9366 more chars]
+  │
+  │ tokens 18 in 272 out 69524 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:27:35 • assistant • Qwen3.8-27B-Think
+  │
+  │ The file looks consistent. One edge case to double-check: in `startTabPolling`, when `name ===
+  │ "overview"`, `setHistoryPolling(true)` calls `pollHistory()`, which then calls `updateCharts` —
+  │ the chart must already be initialized. `initCharts()` on line 170 runs before the trailing
+  │ `showTab(initial)` on line 286 ✓.
+  │
+  │ Another edge case: `updateCharts` references `charts.cpu` — if the Chart.js vendor fails to
+  │ load, `initCharts` returns early and `charts` stays as `{}` → `updateCharts` would throw on
+  │ `charts.cpu.data` — but that `.then(updateCharts)` has a `.catch(() => {})` on it ✓ (same as
+  │ before).
+  │
+  │ Now — one more thing to double-check: **htmx 1.9.12's `ce` (trigger) function**:
+  │ `ce(e,t,r){e=p(e);...}` — `p(e)` normalizes the element. No problem.
+  │
+  │ But wait, there's one more important htmx 1.9.12 detail to verify: in `ht(a,o,e,s,l)`, the event
+  │ handler does:
+  │ ```js
+  │ var i=function(e){
+  │   if(!se(a)){n.removeEventListener(s.trigger,i);return}
+  │   ...
+  │   if(ct(s,a,e)){return}
+  │   var t=ae(e);
+  │   t.triggerSpec=s;
+  │   if(t.handledFor==null){t.handledFor=[]}
+  │   if(t.handledFor.indexOf(a)<0){
+  │     t.handledFor.push(a);
+  │     ...
+  │     ce(a,"htmx:trigger");
+  │     o(a,e)
+  │   }
+  │ }
+  │ ```
+  │
+  │ Hmm wait — `var t=ae(e)` — `ae` is `getInternalData`… applied to the **event**?? That seems
+  │ weird. Let me look at the source more carefully. Actually in the minified dump:
+  │
+  │ ```js
+  │ var
+  │ i=function(e){if(!se(a)){n.removeEventListener(s.trigger,i);return}if(ft(a,e)){return}if(l||ut(e
+  │ ,a)){e.preventDefault()}if(ct(s,a,e)){return}var
+  │ t=ae(e);t.triggerSpec=s;if(t.handledFor==null){t.handledFor=[]}if(t.handledFor.indexOf(a)<0){t.h
+  │ andledFor.push(a);if(s.consume){e.stopPropagation()}if(s.target&&e.target){if(!h(e.target,s.targ
+  │ et)){return}}if(s.once){if(u.triggeredOnce){return}else{u.triggeredOnce=true}}if(s.changed){var
+  │ r=ae(n);if(r.lastValue===n.value){return}r.lastValue=n.value}if(u.delayed){clearTimeout(u.delaye
+  │ d)}if(u.throttle){return}if(s.throttle>0){if(!u.throttle){o(a,e);u.throttle=setTimeout(function(
+  │ ){u.throttle=null},s.thr
+  │ … [6256 more chars]
+  │
+  │ The file is coherent. Now verify all trigger sites, then restart the server and test:
+  │
+  │ grep hx-trigger                                                                      ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "hx-trigger",
+  │       "path": "/home/mac/Code/dashboard/templates"
+  │     }
+  │   out
+  │     Found 14 matches
+  │     /home/mac/Code/dashboard/templates/processes.html:
+  │       Line 1: <div id="processes-body" class="panel" hx-get="/api/processes"
+  │       hx-trigger="dash-poll from:#tab-processes" hx-swap="outerHTML"
+  │       hx-include="#proc-controls">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html:
+  │       Line 2:   <div id="sessions-state" hx-get="/api/plugins/sessions/state"
+  │       hx-trigger="dash-poll from:#tab-plugins" hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/disks.html:
+  │       Line 1: <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="dash-poll
+  │       from:#tab-disks" hx-swap="outerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html:
+  │       Line 2:   <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="dash-poll
+  │       from:#tab-plugins" hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/plugins/lact_skeleton.html:
+  │       Line 2:   <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="dash-poll
+  │       from:#tab-plugins" hx-swap="innerHTML">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/services.html:
+  │       Line 1: <div id="services" class="panel" hx-get="/api/services" hx-trigger="dash-poll
+  │       from:#tab-services" hx-swap="outerHTML" hx-include="#svc-filters">
+  │
+  │
+  │     /home/mac/Code/dashboard/templates/index.html:
+  │       Line 25:     <div id="overview" class="panel" hx-get="/api/overview" hx-trigger="dash-poll
+  │       from:#tab-overview" hx-swap="outerHTML"></div>
+  │
+  │       Line 34:     <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="dash-poll
+  │       from:#tab-disks" hx-swap="outerHTML"></div>
+  │
+  │       Line 55:     <div id="processes-body" class="panel" hx-get="/api/processes"
+  │       hx-trigger="dash-poll from:#tab-processes" hx-swap="outerHTML"
+  │       hx-include="#proc-controls"></div>
+  │
+  │       Line 73:       <div id="journal-log" hx-get="/api/journal" hx-trigger="dash-poll
+  │       from:#tab-journal" hx-swap="beforeend" hx-include="#journal-filters,
+  │       #journal-cursor"></div>
+  │
+  │       Line 91:     <div id="services" class="panel" hx-get="/api/services" hx-trigger="dash-poll
+  │       from:#tab-services" hx
+  │     … [575 more chars]
+  │ bash uv run python -m compileall -q app && echo COMPILE_OK; curl -s -o /dev/null …   ok     0.0s
+  │   in
+  │     {
+  │       "command": "uv run python -m compileall -q app && echo COMPILE_OK; curl -s -o /dev/null -w
+  │       \"%{http_code}\\n\" http://127.0.0.1:8501/api/overview || echo SERVER_DOWN",
+  │       "workdir": "/home/mac/Code/dashboard"
+  │     }
+  │   out
+  │     COMPILE_OK
+  │     200
+  │ bash which node npx chromium chromium-browser google-chrome 2>/dev/null; node --v…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "which node npx chromium chromium-browser google-chrome 2>/dev/null; node
+  │       --version 2>/dev/null; ls /home/mac/Code/dashboard/node_modules 2>/dev/null | head -3;
+  │       python3 -c \"import playwright\" 2>&1 | head -1"
+  │     }
+  │   out
+  │     /usr/bin/node
+  │     /usr/bin/npx
+  │     /usr/bin/chromium
+  │     v22.23.2
+  │     Traceback (most recent call last):
+  │
+  │ tokens 3987 in 2620 out 69813 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:29:34 • assistant • Qwen3.8-27B-Think
+  │
+  │ All 14 trigger sites have been correctly updated. Compilation is OK, and the server is running
+  │ (200). Node v22 and chromium are available — I can write a headless verification script using
+  │ puppeteer-core (which needs to be installed) or the CDP protocol directly.
+  │
+  │ Actually, puppeteer might not be installed. Let me check if puppeteer is available via npx
+  │ (would need a download). As an alternative, use chromium headless with `--dump-dom`? That
+  │ doesn't let me easily observe the request timeline.
+  │
+  │ Better approach: check whether puppeteer/playwright exists globally, or install puppeteer-core
+  │ locally in /tmp (small, doesn't download chromium — use the system chromium at
+  │ /usr/bin/chromium).
+  │
+  │ Plan:
+  │ 1. In /tmp/opencode/verify, npm init + npm i puppeteer-core (fast, no browser download).
+  │ 2. Script:
+  │    - Launch chromium headless, new page
+  │    - Intercept requests, log (timestamp, url)
+  │    - Navigate to http://127.0.0.1:8501/
+  │    - Wait 6 seconds (overview should poll /api/overview 2-3 times, /api/history 3 times; no
+  │    disks/processes/journal/services/plugins)
+  │    - Click the Disks tab button
+  │    - Wait 6 seconds (disks polls; overview should not poll; history should not poll)
+  │    - Click the Plugins tab, wait 2 seconds (plugins should load only once; state divs may poll
+  │    after 5 seconds)
+  │    - Assert against the counts
+  │
+  │ Note: the server is running the old… no wait, the server is running the current code — but
+  │ template changes are auto-reloaded, static js is served from disk. No Python changes, so no
+  │ restart needed. However, AGENTS.md says Python changes require a restart — I haven't made any.
+  │ Still, just to be safe, the server was already running — no problem.
+  │
+  │ One caveat: the running server was started before my changes — but since no Python files were
+  │ changed, it will serve the new templates/static. Good.
+  │
+  │ Let me write the verification script. First, check the npm availability/network for installing
+  │ puppeteer-core. If there's no network, fall back to raw CDP via websocket… Node 22 has
+  │ … [488 more chars]
+  │
+  │ All 14 sites updated, compile OK, server is running (no Python changes, so no restart needed).
+  │ Chromium + node are available — let me run a real headless verification of the polling behavior:
+  │
+  │ bash mkdir -p /tmp/opencode/verify && cd /tmp/opencode/verify && npm init -y >/de…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "mkdir -p /tmp/opencode/verify && cd /tmp/opencode/verify && npm init -y
+  │       >/dev/null 2>&1 && npm i puppeteer-core --no-audit --no-fund 2>&1 | tail -2",
+  │       "timeout": 120000
+  │     }
+  │   out
+  │
+  │     added 25 packages in 2s
+  │
+  │ tokens 3452 in 734 out 73796 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:30:21 • assistant • Qwen3.8-27B-Think
+  │
+  │ puppeteer-core has been installed. Next, I'll write the verification script:
+  │
+  │ ```js
+  │ const puppeteer = require("puppeteer-core");
+  │
+  │ (async () => {
+  │   const browser = await puppeteer.launch({
+  │     executablePath: "/usr/bin/chromium",
+  │     headless: "new",
+  │     args: ["--no-sandbox", "--disable-dev-shm-usage"],
+  │   });
+  │   const page = await browser.newPage();
+  │   const reqs = []; // {t, url}
+  │   const t0 = Date.now();
+  │   page.on("request", (r) => {
+  │     const u = r.url();
+  │     if (u.includes("/api/")) reqs.push({ t: Date.now() - t0, url: u });
+  │   });
+  │   const errors = [];
+  │   page.on("pageerror", (e) => errors.push(String(e)));
+  │   page.on("console", (m) => { if (m.type() === "error") errors.push(m.text()); });
+  │
+  │   await page.goto("http://127.0.0.1:8501/", { waitUntil: "networkidle2" });
+  │
+  │   const counts = () => {
+  │     const c = {};
+  │     for (const r of reqs) {
+  │       const k = r.url.replace("http://127.0.0.1:8501", "").split("?")[0];
+  │       c[k] = (c[k] || 0) + 1;
+  │     }
+  │     return c;
+  │   };
+  │   const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  │
+  │   // Phase 1: overview active
+  │   await sleep(6000);
+  │   const c1 = counts();
+  │   console.log("after 6s on overview:", JSON.stringify(c1));
+  │
+  │   // Phase 2: switch to disks
+  │   await page.click('button[data-tab="disks"]');
+  │   await sleep(6000);
+  │   const c2 = counts();
+  │   console.log("after 6s on disks:    ", JSON.stringify(c2));
+  │
+  │   // Phase 3: switch to plugins
+  │   await page.click('button[data-tab="plugins"]');
+  │   await sleep(7000);
+  │   const c3 = counts();
+  │   console.log("after 7s on plugins:  ", JSON.stringify(c3));
+  │
+  │   const d = (a, b) => {
+  │     const o = {};
+  │     const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  │     for (const k of keys) o[k] = (b[k] || 0) - (a[k] || 0);
+  │     return o;
+  │   };
+  │   console.log("delta phase1->2:", JSON.stringify(d(c1, c2)));
+  │   console.log("delta phase2->3:", JSON.stringify(d(c2, c3)));
+  │
+  │   // Assertions
+  │   const fail = [];
+  │   // Phase 1: only overview + history are polled; no disks/processes/journal/services/plugins
+  │   if (c1["/ap
+  │ … [6175 more chars]
+  │
+  │ puppeteer-core installed. Writing a headless verification script that tracks API requests per
+  │ phase (overview → disks → plugins):
+  │
+  │ write /tmp/opencode/verify/verify.js                                                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/tmp/opencode/verify/verify.js",
+  │       "content": "const puppeteer = require(\"puppeteer-core\");\n\n(async () => {\n  const
+  │       browser = await puppeteer.launch({\n    executablePath: \"/usr/bin/chromium\",\n
+  │       headless: true,\n    args: [\"--no-sandbox\", \"--disable-dev-shm-usage\"],\n  });\n
+  │       const page = await browser.newPage();\n  const reqs = [];\n  const errors = [];\n  const
+  │       t0 = Date.now();\n  page.on(\"request\", (r) => {\n    const u = r.url();\n    if
+  │       (u.includes(\"/api/\")) reqs.push({ t: Date.now() - t0, url: u });\n  });\n
+  │       page.on(\"pageerror\", (e) => errors.push(String(e)));\n  page.on(\"console\", (m) => {\n
+  │       if (m.type() === \"error\") errors.push(m.text());\n  });\n\n  await
+  │       page.goto(\"http://127.0.0.1:8501/\", { waitUntil: \"load\" });\n  const sleep = (ms) =>
+  │       new Promise((r) => setTimeout(r, ms));\n\n  const countsIn = (from, to) => {\n    const c
+  │       = {};\n    for (const r of reqs) {\n      if (r.t < from || r.t >= to) continue;\n
+  │       const k = r.url.replace(\"http://127.0.0.1:8501\", \"\").split(\"?\")[0];\n      c[k] =
+  │       (c[k] || 0) + 1;\n    }\n    return c;\n  };\n\n  // phase 1: overview (default tab)\n
+  │       await sleep(6000);\n  const t1 = Date.now() - t0;\n  const c1 = countsIn(0, t1);\n
+  │       console.log(\"phase1 overview :\", JSON.stringify(c1));\n\n  // phase 2: switch to disks\n
+  │       await page.click('button[data-tab=\"disks\"]');\n  await sleep(6000);\n  const t2 =
+  │       Date.now() - t0;\n  const c2 = countsIn(t1, t2);\n  console.log(\"phase2 disks    :\",
+  │       JSON.stringify(c2));\n\n  // phase 3: switch to plugins\n  await
+  │       page.click('button[data-tab=\"plugins\"]');\n  await sleep(7000);\n  const c3 =
+  │       countsIn(t2, Date.now() - t0);\n  console.log(\"phase3 plugins  :\",
+  │       JSON.stringify(c3));\n\n  const fail = [];\n  if ((c1[\"/api/overview\"] || 0) < 2)
+  │       fail.push(\"overview should poll ~3x in 6s, got \" + (c1[\"/api/overview\"] || 0));\n  if
+  │       ((c1[\"/api/history\"] || 0) < 2) fail.push(\"history should poll while overview active,
+  │       got \" + (c1[\"
+  │     … [1428 more chars]
+  │   out Wrote file successfully.
+  │
+  │ tokens 24 in 3588 out 77982 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:32:45 • assistant • Qwen3.8-27B-Think
+  │
+  │ Alright, let's run the verification. Note that the server is already running (no Python changes,
+  │ and templates/static files are served from disk with auto-reload). Executing.
+  │
+  │ bash node /tmp/opencode/verify/verify.js                                             ok     0.1s
+  │   in
+  │     {
+  │       "command": "node /tmp/opencode/verify/verify.js",
+  │       "timeout": 90000
+  │     }
+  │   out
+  │     phase1 overview : {"/api/history":4,"/api/overview":3}
+  │     phase2 disks    : {"/api/disks":4}
+  │     phase3 plugins  :
+  │     {"/api/plugins":1,"/api/plugins/llamacpp/state":1,"/api/plugins/sleep/state":1,"/api/plugins
+  │     /lact/state":1,"/api/plugins/sessions/state":1}
+  │     FAIL:
+  │     - page errors: Failed to load resource: the server responded with a status of 404 (Not
+  │     Found)
+  │
+  │ tokens 20 in 90 out 81594 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:33:10 • assistant • Qwen3.8-27B-Think
+  │
+  │ The polling behavior is completely correct:
+  │ - Phase 1 (overview): only /api/overview (3 times) + /api/history (4 times). Nothing else. ✓
+  │ - Phase 2 (disk): only /api/disks (4 times). Overview and history are stopped. ✓
+  │ - Phase 3 (plugin): /api/plugins once + 4 state divs each polled once. Disk is stopped. ✓
+  │
+  │ The only failure: a 404 error in the console. Which resource is 404? My console error listener
+  │ is picking up the "Failed to load resource" for the 404. I need to identify which URL. Probably
+  │ an existing 404 (e.g., favicon.ico) and unrelated to my changes. Let's capture the URL of the
+  │ 404 and check. Also, check whether this 404 existed before my changes (favicon is the prime
+  │ suspect — index.html has no favicon link).
+  │
+  │ Let's modify the script to log the URL of the failed request (response status). Quickly: add
+  │ page.on("response") to log non-2xx with URL.
+  │
+  │ Polling behavior is exactly right. The only failure is a 404 — let me identify which resource
+  │ (likely pre-existing, e.g. favicon):
+  │
+  │ bash cd /tmp/opencode/verify && node -e ' const puppeteer = require("puppeteer-co…   ok     4.1s
+  │   in
+  │     {
+  │       "command": "cd /tmp/opencode/verify && node -e '\nconst puppeteer =
+  │       require(\"puppeteer-core\");\n(async () => {\n  const browser = await puppeteer.launch({
+  │       executablePath: \"/usr/bin/chromium\", headless: true, args: [\"--no-sandbox\",
+  │       \"--disable-dev-shm-usage\"] });\n  const page = await browser.newPage();\n
+  │       page.on(\"response\", (r) => { if (r.status() >= 400) console.log(r.status(), r.url());
+  │       });\n  await page.goto(\"http://127.0.0.1:8501/\", { waitUntil: \"load\" });\n  await new
+  │       Promise((r) => setTimeout(r, 4000));\n  await browser.close();\n})();'",
+  │       "timeout": 60000
+  │     }
+  │   out 404 http://127.0.0.1:8501/favicon.ico
+  │
+  │ tokens 127 in 481 out 81703 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:33:35 • assistant • Qwen3.8-27B-Think
+  │
+  │ As expected — the 404 is due to `favicon.ico`, which is existing behavior (the page has no
+  │ favicon link), unrelated to my changes. Not a regression.
+  │
+  │ Next, I'll also verify the journal catch-up behavior and the visibilitychange pause. The
+  │ visibilitychange test in headless: can I emulate it with `page.evaluate(() => {
+  │ Object.defineProperty(document, 'hidden', {value: true}); document.dispatchEvent(new
+  │ Event('visibilitychange')); })`? Hmm — `document.hidden` is a getter on Document.prototype, and
+  │ overriding it with defineProperty on the instance works. But a cleaner test: CDP's
+  │ `Emulation.setDocumentCookie`… no, that's wrong. CDP has `Emulation.setDeviceMetricsOverride`…
+  │ for visibility, there's no direct CDP command in older versions; newer Chrome has
+  │ `Emulation.setFocusEmulationEnabled`? Actually, the simplest is: monkey-patch `document.hidden`
+  │ and dispatch the event — my code reads `document.hidden` at event time, so the monkey-patch
+  │ works.
+  │
+  │ Journal catch-up test:
+  │ 1. Open the journal tab, wait about 6 seconds (fetch the first 100 lines, get the cursor).
+  │ 2. Switch to the disks tab (the journal pauses).
+  │ 3. Generate log lines: `logger -t verifytest "line N"` a few times (logger is available on most
+  │ systems; the dashboard reads the journal via sudo journalctl).
+  │ 4. Wait about 4 seconds (no journal requests should occur — verify that no /api/journal requests
+  │ happen while on disks).
+  │ 5. Return to the journal tab, wait about 6 seconds → the new lines should appear in the DOM
+  │ (verify that #journal-log contains the text of the new lines).
+  │
+  │ Let's write this second script. About the logger: check `which logger`. This is a Linux desktop
+  │ (systemd), so logger should exist. Lines: `logger -t dashverify "unique marker XYZ123 line i"`.
+  │
+  │ After that, assert that the text appears in the journal DOM.
+  │
+  │ Also verify the visibility pause:
+  │ - On the overview tab, wait 3 seconds (confirm polling is occurring)
+  │ - Monkey-patch hidden=true, dispatch visibilitychange → wait 3 seconds → confirm no /ap
+  │ … [150 more chars]
+  │
+  │ Existing `favicon.ico` 404 — unrelated. Next, I'll verify the two remaining behaviors: **journal
+  │ catch-up** (when paused, the cursor is frozen and then drained on return), and **page visibility
+  │ pause**:
+  │
+  │ write /tmp/opencode/verify/verify2.js                                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/tmp/opencode/verify/verify2.js",
+  │       "content": "const puppeteer = require(\"puppeteer-core\");\nconst { execSync } =
+  │       require(\"child_process\");\n\n(async () => {\n  const browser = await
+  │       puppeteer.launch({\n    executablePath: \"/usr/bin/chromium\",\n    headless: true,\n
+  │       args: [\"--no-sandbox\", \"--disable-dev-shm-usage\"],\n  });\n  const page = await
+  │       browser.newPage();\n  const reqs = [];\n  const errors = [];\n  const t0 = Date.now();\n
+  │       page.on(\"request\", (r) => {\n    const u = r.url();\n    if (u.includes(\"/api/\"))
+  │       reqs.push({ t: Date.now() - t0, url: u });\n  });\n  page.on(\"pageerror\", (e) =>
+  │       errors.push(String(e)));\n  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));\n
+  │       const count = (from, to, pred) => reqs.filter((r) => r.t >= from && r.t < to &&
+  │       pred(r.url)).length;\n\n  const MARK = \"dashverify-\" + process.pid;\n\n  await
+  │       page.goto(\"http://127.0.0.1:8501/\", { waitUntil: \"load\" });\n  const fail = [];\n\n
+  │       // --- journal catch-up ---\n  await page.click('button[data-tab=\"journal\"]');\n  await
+  │       sleep(6000); // first page loads, cursor tracked\n  const jBase = Date.now() - t0;\n\n  //
+  │       leave journal (pause), generate log lines while paused\n  await
+  │       page.click('button[data-tab=\"disks\"]');\n  execSync(`for i in 1 2 3 4 5; do logger -t
+  │       dashverify \"marker ${MARK} line $i\"; done`);\n  await sleep(4000);\n  const jPaused =
+  │       Date.now() - t0;\n  const pausedReqs = count(jBase, jPaused, (u) =>
+  │       u.includes(\"/api/journal\"));\n  console.log(\"journal requests while paused (on
+  │       disks):\", pausedReqs);\n  if (pausedReqs > 0) fail.push(\"journal polled while its tab is
+  │       hidden: \" + pausedReqs);\n\n  // return to journal; backlog should be caught up and
+  │       visible\n  await page.click('button[data-tab=\"journal\"]');\n  await sleep(6000);\n
+  │       const lines = await page.$$eval(\"#journal-log .jline\", (els) => els.map((e) =>
+  │       e.textContent));\n  const hits = lines.filter((l) => l.includes(MARK)).length;\n
+  │       console.log(\"journal lin
+  │     … [1724 more chars]
+  │   out Wrote file successfully.
+  │
+  │ tokens 37 in 1668 out 82310 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:34:42 • assistant • Qwen3.8-27B-Think
+  │
+  │ Let's try running the second verification. Note: the journal tab is restored from localStorage —
+  │ wait, in the first script I clicked disks and then plugins, so localStorage now has "plugins"
+  │ saved. In this script, the first goto will restore the plugins tab (because of localStorage's
+  │ "dash.tab"). After that, I explicitly click journal — that's fine, showTab("journal") will run.
+  │
+  │ Hmm, wait — but the restored tab will be plugins: dash-activate fires → /api/plugins fetch. No
+  │ problem, doesn't affect the assertions (I'm explicitly counting requests in the time window).
+  │
+  │ Actually, one more thing to double-check: in the journal phase, after clicking the disks tab, I
+  │ wait 4 seconds and then generate… no wait, the order is: click disks, then logger (immediately),
+  │ then sleep 4 seconds. Journal is paused → no journal requests during that time. But wait — the
+  │ logger command runs while on the disks tab. The journal cursor is frozen at the last fetched
+  │ line. The new lines come after that. Then, going back to journal: the first dash-poll fires with
+  │ the old cursor → fetches 200 lines → includes the 5 marker lines.
+  │
+  │ One risk: `logger -t dashverify` — the journal entry's SYSLOG_IDENTIFIER will be "dashverify"
+  │ and the message will be "marker dashverify-PID line N". The jline text includes the identifier +
+  │ message. The MARK check `l.includes(MARK)` — MARK = "dashverify-PID" appears in the message. ✓
+  │ (Note: the identifier is "dashverify" and the message contains "dashverify-PID" — the PID makes
+  │ it unique per run.)
+  │
+  │ Let's run it.
+  │
+  │ bash node /tmp/opencode/verify/verify2.js                                            ok     0.1s
+  │   in
+  │     {
+  │       "command": "node /tmp/opencode/verify/verify2.js",
+  │       "timeout": 90000
+  │     }
+  │   out
+  │     journal requests while paused (on disks): 0
+  │     journal lines with marker after return: 5 of 5
+  │     overview+history requests while page hidden: 0
+  │     overview+history requests after resume: 4
+  │     ALL CHECKS PASSED
+  │
+  │ tokens 21 in 413 out 84014 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:35:30 • assistant • Qwen3.8-27B-Think
+  │
+  │ All behaviors verified:
+  │
+  │ 1. **Only the active tab polls**: Phase 1 overview → only `/api/overview` + `/api/history`;
+  │ Phase 2 disks → only `/api/disks`; Phase 3 plugins → plugins list + 4 state divs.
+  │ 2. **Journal catch-up**: 0 journal requests while paused; all 5 lines generated while paused
+  │ appear after returning.
+  │ 3. **Visibility pause**: 0 requests while the page is hidden; polling resumes after it becomes
+  │ visible again.
+  │
+  │ Now, final check per AGENTS.md:
+  │ - `uv run python -m compileall -q app` ✓ (already done, COMPILE_OK)
+  │ - curl endpoints → 200 (overview already confirmed; quickly verify the rest)
+  │ - `grep -c Traceback /tmp/dash.log` — /tmp/dash.log only exists if the server was started with
+  │ the documented restart command. The server is already running; the log file may or may not
+  │ exist. Let me check the endpoints and the log.
+  │
+  │ Also — should I restart the server per AGENTS.md? I haven't made any Python changes, so it's not
+  │ needed. Templates are auto-reloaded, and static is served from disk. The running server has
+  │ already served the new templates (the verification was run against it). No restart needed.
+  │
+  │ Let me run the final endpoint check + tracebacks in the log.
+  │
+  │ All checks pass. Final verification per AGENTS.md — all endpoints + traceback check:
+  │
+  │ bash for ep in overview disks processes journal services plugins history; do prin…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "for ep in overview disks processes journal services plugins history; do printf
+  │       \"%-10s \" $ep; curl -s -o /dev/null -w \"%{http_code}\\n\" http://127.0.0.1:8501/api/$ep;
+  │       done; echo \"tracebacks: $(grep -c Traceback /tmp/dash.log 2>/dev/null || echo 'no log
+  │       file (server predates this session)')\"",
+  │       "workdir": "/home/mac/Code/dashboard"
+  │     }
+  │   out
+  │     overview   200
+  │     disks      200
+  │     processes  200
+  │     journal    200
+  │     services   200
+  │     plugins    200
+  │     history    200
+  │     tracebacks: 0
+  │     no log file (server predates this session)
+  │
+  │ tokens 64 in 449 out 84449 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:35:51 • assistant • Qwen3.8-27B-Think
+  │
+  │ All 7 endpoints return 200, no tracebacks.
+  │
+  │ Summary of changes:
+  │ - 14 template locations: `hx-trigger="every Ns"` / `load` → `dash-poll from:#tab-<name>` (and
+  │ for the plugin shell, `dash-activate from:#tab-plugins`)
+  │ - app.js: polling scoped per tab, gating of the chart's history polling, pause/resume via
+  │ visibilitychange, initial tab startup at the end of the IIFE
+  │
+  │ Verified with 2 headless browser runs:
+  │ 1. Only the active tab polls (overview→disks→plugins phases)
+  │ 2. Journal: no requests while paused, catches up on all 5 lines on resume
+  │ 3. Page hidden: 0 requests; resumes on becoming visible
+  │ 4. All endpoints 200, no tracebacks
+  │
+  │ Marking the TODO as complete. Cleanup? The verification script is in /tmp/opencode/verify — it's
+  │ a temporary directory so no problem leaving it as is.
+  │
+  │ Final concise summary for the user.
+  │
+  │ Done and verified. All endpoints 200, zero tracebacks.
+  │
+  │ todowrite 0 todos                                                                    ok     0.0s
+  │   in
+  │     {
+  │       "todos": [
+  │         {
+  │           "content": "Update hx-trigger in index.html (6 sites)",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Update hx-trigger in 8 fragment templates",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Rework app.js: tab-scoped polling + charts gating + visibility pause",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         },
+  │         {
+  │           "content": "Restart server and verify endpoints + no tracebacks",
+  │           "status": "completed",
+  │           "priority": "high"
+  │         }
+  │       ]
+  │     }
+  │   out
+  │     [
+  │       {
+  │         "content": "Update hx-trigger in index.html (6 sites)",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Update hx-trigger in 8 fragment templates",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Rework app.js: tab-scoped polling + charts gating + visibility pause",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       },
+  │       {
+  │         "content": "Restart server and verify endpoints + no tracebacks",
+  │         "status": "completed",
+  │         "priority": "high"
+  │       }
+  │     ]
+  │
+  │ tokens 81 in 375 out 84963 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 02:36:07 • assistant • Qwen3.8-27B-Think
+  │
+  │ Done. Final summary — keep it concise, mention what was changed and the verification results.
+  │
+  │ Implemented and verified with headless Chromium against the live server:
+  │
+  │ **Changes**
+  │ - **14 template sites** — `hx-trigger="load, every Ns"` → `hx-trigger="dash-poll
+  │ from:#tab-<name>"`; the plugins shell uses one-shot `dash-activate from:#tab-plugins` (defers
+  │ `/api/plugins` until the tab is first opened)
+  │ - **`static/js/app.js`** — `startTabPolling()` fires `dash-activate` + `dash-poll` on the active
+  │ section and runs one `setInterval` at that tab's original interval (2s/2s/3s/5s/15s/5s);
+  │ `showTab()` drives it; the charts' `/api/history` loop is gated on Overview; `visibilitychange`
+  │ pauses/resumes everything when the browser tab is hidden
+  │
+  │ **Verified behavior**
+  │ - On overview: only `/api/overview` + `/api/history` fire —
+  │ disks/processes/journal/services/plugins make zero requests
+  │ - Switch to disks: disks polls, overview/history stop; switch to plugins: list loads once + 4
+  │ state divs poll
+  │ - Journal: 0 requests while paused; all 5 log lines generated while paused appear on return
+  │ (cursor catch-up works)
+  │ - Page hidden: 0 requests; resume: polling picks up with a fresh fetch
+  │
+  │ The one 404 in console is the pre-existing missing favicon, unrelated. No restart was needed (no
+  │ Python changes); all endpoints return 200.
+  │
+  │ tokens 175 in 342 out 85419 cached 0 written $0.0000 stop
+
diff --git a/opencode/012_opencode_session_selective_refresh_subagent_2026-08-31.txt b/opencode/012_opencode_session_selective_refresh_subagent_2026-08-31.txt
new file mode 100644
index 0000000..4400a55
--- /dev/null
+++ b/opencode/012_opencode_session_selective_refresh_subagent_2026-08-31.txt
@@ -0,0 +1,2067 @@
+dashboard  2026-08-30 02:42:55 → now  1 session(s)
+
+Session  Started           Where  Title
+Ch6QXt↓  2026-08-31 01:53  .      Explore tab structure (@explore subagent)
+
+
+ ⚑ ❬Ch6QXt↓❭ Explore tab structure (@explore subagent)                              ~/Code/dashboard
+┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
+
+  │ 2026-08-31 01:53:49 • user
+  │
+  │ Explore the dashboard codebase at /home/mac/Code/dashboard. I need to understand the tab system
+  │ in detail:
+  │
+  │ 1. Read templates/ directory - list all files, and read the main index template (probably
+  │ templates/index.html) and 2-3 example tab templates (e.g. overview.html, disks.html,
+  │ processes.html or similar)
+  │ 2. How are tabs structured? Look for tab navigation markup, tab switching mechanism (JS, htmx
+  │ attributes, classes like .active)
+  │ 3. How does polling work? Look for hx-get, hx-trigger, hx-swap attributes - which elements poll,
+  │ at what intervals
+  │ 4. Is there any existing JavaScript in the templates or static/ files? Read any .js files found
+  │ 5. Check if there's a static/ directory with CSS/JS
+  │ 6. Look at how the tab buttons work - is it pure htmx, or is there JS handling tab activation?
+  │ 7. Check app/routers/ for any tab-related endpoints
+  │
+  │ Report back with:
+  │ - Exact file listing of templates/ and static/ (if exists)
+  │ - The full content of the main index.html template
+  │ - Full content of 2-3 representative tab templates (showing their polling setup)
+  │ - Any existing JS code
+  │ - How tab switching currently works (the exact mechanism)
+  │ - Polling intervals used per tab/section
+  │
+  │ Be very thorough - include actual code snippets with line numbers.
+
+
+  │ 2026-08-31 01:53:49 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ I'll start by exploring the structure of the codebase. I'll list the templates directory and the
+  │ static directory, and read the main files in parallel.
+  │
+  │ I'll explore the dashboard codebase thoroughly, starting with the directory structure and main
+  │ files.
+  │
+  │ bash ls -la /home/mac/Code/dashboard/templates/ 2>/dev/null; echo "---STATIC---";…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "ls -la /home/mac/Code/dashboard/templates/ 2>/dev/null; echo \"---STATIC---\";
+  │       ls -la /home/mac/Code/dashboard/static/ 2>/dev/null || echo \"no static dir\""
+  │     }
+  │   out
+  │     total 36
+  │     drwxr-xr-x 1 mac mac  220 30. Aug 19:44 .
+  │     drwxr-xr-x 1 mac mac  306 30. Aug 22:11 ..
+  │     -rw-r--r-- 1 mac mac 2013 29. Aug 21:17 disks.html
+  │     -rw-r--r-- 1 mac mac 4442 30. Aug 20:40 index.html
+  │     -rw-r--r-- 1 mac mac  404 29. Aug 20:17 journal.html
+  │     -rw-r--r-- 1 mac mac 4057 29. Aug 22:14 overview.html
+  │     drwxr-xr-x 1 mac mac  300 31. Aug 01:29 plugins
+  │     -rw-r--r-- 1 mac mac  326 30. Aug 21:31 plugins.html
+  │     -rw-r--r-- 1 mac mac 2052 29. Aug 21:54 processes.html
+  │     -rw-r--r-- 1 mac mac 1112 30. Aug 20:37 service_detail.html
+  │     -rw-r--r-- 1 mac mac 4024 30. Aug 20:40 services.html
+  │     ---STATIC---
+  │     total 0
+  │     drwxr-xr-x 1 mac mac  22 29. Aug 21:19 .
+  │     drwxr-xr-x 1 mac mac 306 30. Aug 22:11 ..
+  │     drwxr-xr-x 1 mac mac  18 30. Aug 22:11 css
+  │     drwxr-xr-x 1 mac mac  12 30. Aug 18:16 js
+  │     drwxr-xr-x 1 mac mac  54 29. Aug 20:07 vendor
+  │ glob **/*.js                                                                         ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "**/*.js"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/static/vendor/chart.umd.min.js
+  │     /home/mac/Code/dashboard/static/vendor/htmx.min.js
+  │     /home/mac/Code/dashboard/static/js/app.js
+  │ glob app/routers/*                                                                   ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "app/routers/*"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/app/routers/services.py
+  │     /home/mac/Code/dashboard/app/routers/overview.py
+  │     /home/mac/Code/dashboard/app/routers/plugins.py
+  │     /home/mac/Code/dashboard/app/routers/__init__.py
+  │     /home/mac/Code/dashboard/app/routers/journal.py
+  │     /home/mac/Code/dashboard/app/routers/processes.py
+  │     /home/mac/Code/dashboard/app/routers/disks.py
+  │
+  │ tokens 5114 in 180 out 0 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:54:00 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ Let's explore further. I'll list the static directory, the plugins templates directory, and then
+  │ read the main files.
+  │
+  │ Let me explore the static directory, plugins templates, and read the main index template.
+  │
+  │ bash echo "=== static/css ==="; ls -la /home/mac/Code/dashboard/static/css/; echo…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "echo \"=== static/css ===\"; ls -la /home/mac/Code/dashboard/static/css/; echo
+  │       \"=== static/js ===\"; ls -la /home/mac/Code/dashboard/static/js/; echo \"===
+  │       static/vendor ===\"; ls -la /home/mac/Code/dashboard/static/vendor/; echo \"===
+  │       templates/plugins ===\"; ls -la /home/mac/Code/dashboard/templates/plugins/"
+  │     }
+  │   out
+  │     === static/css ===
+  │     total 12
+  │     drwxr-xr-x 1 mac mac   18 30. Aug 22:11 .
+  │     drwxr-xr-x 1 mac mac   22 29. Aug 21:19 ..
+  │     -rw-r--r-- 1 mac mac 9441 30. Aug 22:11 style.css
+  │     === static/js ===
+  │     total 8
+  │     drwxr-xr-x 1 mac mac   12 30. Aug 18:16 .
+  │     drwxr-xr-x 1 mac mac   22 29. Aug 21:19 ..
+  │     -rw-r--r-- 1 mac mac 8178 30. Aug 20:37 app.js
+  │     === static/vendor ===
+  │     total 252
+  │     drwxr-xr-x 1 mac mac     54 29. Aug 20:07 .
+  │     drwxr-xr-x 1 mac mac     22 29. Aug 21:19 ..
+  │     -rw-r--r-- 1 mac mac 205125 29. Aug 20:07 chart.umd.min.js
+  │     -rw-r--r-- 1 mac mac  48101 29. Aug 20:07 htmx.min.js
+  │     === templates/plugins ===
+  │     total 32
+  │     drwxr-xr-x 1 mac mac  300 31. Aug 01:29 .
+  │     drwxr-xr-x 1 mac mac  220 30. Aug 19:44 ..
+  │     -rw-r--r-- 1 mac mac 1011 30. Aug 22:06 lact_skeleton.html
+  │     -rw-r--r-- 1 mac mac  713 30. Aug 22:06 lact_state.html
+  │     -rw-r--r-- 1 mac mac  982 30. Aug 19:44 llamacpp_skeleton.html
+  │     -rw-r--r-- 1 mac mac 1705 30. Aug 19:44 llamacpp_state.html
+  │     -rw-r--r-- 1 mac mac  194 31. Aug 01:29 sessions_skeleton.html
+  │     -rw-r--r-- 1 mac mac 1091 31. Aug 01:29 sessions_state.html
+  │     -rw-r--r-- 1 mac mac  182 30. Aug 21:21 sleep_skeleton.html
+  │     -rw-r--r-- 1 mac mac 1502 30. Aug 21:21 sleep_state.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:
+  │     … [2964 more chars]
+  │
+  │ tokens 606 in 181 out 5294 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:54:06 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ I've obtained the complete index.html. Next, I'll read the following:
+  │ 1. app.js (existing JS)
+  │ 2. style.css (to check the .hidden class and tab styles)
+  │ 3. Representative tab templates: overview.html, disks.html, processes.html
+  │ 4. Router for tab-related endpoints
+  │
+  │ Let's execute these reads in parallel.
+  │
+  │ Now let me read the JS, CSS, and the representative tab templates.
+  │
+  │ 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
+  │     … [7354 more chars]
+  │ read /home/mac/Code/dashboard/templates/overview.html                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/overview.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/overview.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="every 2s"
+  │     hx-swap="outerHTML">
+  │     2:   {% macro bar(pct) %}{% if pct is not none %}<div class="bar"><div class="bar-fill{% if
+  │     pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct }}%"></div></div>{%
+  │     endif %}{% endmacro %}
+  │     3:   {% macro barrow(label, pct, cls) %}{% if pct is not none %}<div class="barrow"><span
+  │     class="barrow-label">{{ label }}</span><div class="bar"><div class="bar-fill{% if cls %} {{
+  │     cls }}{% endif %}{% if pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{
+  │     pct }}%"></div></div></div>{% endif %}{% endmacro %}
+  │     4:   <div class="card">
+  │     5:     <div class="card-label">CPU / GPU</div>
+  │     6:     <div class="card-value">{{ (c.cpu | default(0, true)) | round(1) }}%</div>
+  │     7:     {{ barrow("CPU", c.cpu) }}
+  │     8:     {{ barrow("GPU", c.gpu, "gpu") }}
+  │     9:     {% if c.cpu_temp is not none or c.gpu_temp is not none %}
+  │     10:       <div class="card-sub">
+  │     11:         {% if c.cpu_temp is not none %}CPU {{ c.cpu_temp | round(0) | int }}&deg;C{%
+  │     endif %}
+  │     12:         {% if c.cpu_temp is not none and c.gpu_temp is not none %} &middot;{% endif %}
+  │     13:         {% if c.gpu_temp is not none %}GPU {{ c.gpu_temp | round(0) | int }}&deg;C{%
+  │     endif %}
+  │     14:       </div>
+  │     15:     {% endif %}
+  │     16:     <div class="card-sub">load {{ (c.load1 | default(0, true)) | round(2) }} &middot; {{
+  │     c.cores }} cores</div>
+  │     17:   </div>
+  │     18:   <div class="card">
+  │     19:     <div class="card-label">Memory</div>
+  │     20:     <div class="card-value">{{ c.mem_used | humanize }} <span class="muted">/ {{
+  │     c.mem_total | humanize }} ({{ (c.mem_pct | default(0, true)) | round(0) | int
+  │     }}%)</span></div>
+  │     21:     {{ bar(c.mem_pct) }}
+  │     22:     <div class="memrow">
+  │     23:       <div class="memrow-text">Swap {% if c.swap_total %}{{ c.swap_used | humanize }}
+  │     <span class="muted">/ {{ c.swap_total | humanize }} ({{ (c.swap_pct | default(0, true)) |
+  │     … [2464 more chars]
+  │ read /home/mac/Code/dashboard/templates/disks.html                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/disks.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/disks.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="every 2s"
+  │     hx-swap="outerHTML">
+  │     2:   <h2>Filesystems</h2>
+  │     3:   <div class="part-list">
+  │     4:     {% for p in partitions %}
+  │     5:     <div class="part">
+  │     6:       <div class="part-head">
+  │     7:         <span class="mono">{{ p.device }}</span>
+  │     8:         <span class="muted">{{ p.fstype }}</span>
+  │     9:         <span class="muted part-mounts" title="{{ p.mounts | join("\n") }}">{{
+  │     p.mounts_disp }}</span>
+  │     10:         <span class="part-usage">{{ p.used | humanize }} / {{ p.total | humanize }} ({{
+  │     p.pct | round(0) }}%)</span>
+  │     11:       </div>
+  │     12:       <div class="bar"><div class="bar-fill{% if p.pct > 90 %} hot{% elif p.pct > 75 %}
+  │     warm{% endif %}" style="width: {{ p.pct }}%"></div></div>
+  │     13:     </div>
+  │     14:     {% else %}
+  │     15:     <div class="muted">no partitions found</div>
+  │     16:     {% endfor %}
+  │     17:   </div>
+  │     18:   <h2>Device I/O</h2>
+  │     19:   <div class="table-wrap">
+  │     20:     <table class="table">
+  │     21:       <colgroup>
+  │     22:         <col style="width: 110px">
+  │     23:         <col style="width: 100px">
+  │     24:         <col style="width: 100px">
+  │     25:         <col style="width: 100px">
+  │     26:         <col style="width: 100px">
+  │     27:         <col style="width: 110px">
+  │     28:         <col style="width: 110px">
+  │     29:       </colgroup>
+  │     30:       <thead>
+  │     31:         <tr><th>Device</th><th class="num">Read</th><th class="num">Write</th><th
+  │     class="num">Read rate</th><th class="num">Write rate</th><th class="num">Reads</th><th
+  │     class="num">Writes</th></tr>
+  │     32:       </thead>
+  │     33:       <tbody>
+  │     34:       {% for d in per_disk %}
+  │     35:         <tr>
+  │     36:           <td class="mono cell-clip" title="{{ d.device }}">{{ d.device }}</td>
+  │     37:           <td class="num">{{ d.read_bytes | humanize }}</td>
+  │     38:           <td class="num">{{ d.write_bytes | humanize }}</td>
+  │     39:           <td class="num">{{ d.read_rate | rate }}</td>
+  │     40:           <td class="num">{{ d.write_rate | rate }}</td>
+  │     41:
+  │     … [333 more chars]
+  │ read /home/mac/Code/dashboard/templates/processes.html                               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/processes.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/processes.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="every 3s"
+  │     hx-swap="outerHTML" hx-include="#proc-controls">
+  │     2:   <div class="muted small">showing {{ procs | length }} of {{ total }} processes</div>
+  │     3:   <div class="table-wrap">
+  │     4:     <table class="table">
+  │     5:       <colgroup>
+  │     6:         <col style="width: 64px">
+  │     7:         <col>
+  │     8:         <col style="width: 100px">
+  │     9:         <col style="width: 72px">
+  │     10:         <col style="width: 72px">
+  │     11:         <col style="width: 92px">
+  │     12:         <col style="width: 92px">
+  │     13:         <col style="width: 92px">
+  │     14:         <col style="width: 92px">
+  │     15:       </colgroup>
+  │     16:       <thead>
+  │     17:         <tr>
+  │     18:           {% for col, label in [("pid", "PID"), ("name", "Name"), ("user", "User"),
+  │     ("cpu", "CPU%"), ("mem_pct", "MEM%"), ("rss", "RSS"), ("gpu", "GPU"), ("io_read", "IO
+  │     read"), ("io_write", "IO write")] %}
+  │     19:           <th class="{% if col in ('cpu','mem_pct','rss','gpu','io_read','io_write')
+  │     %}num{% endif %}">
+  │     20:             <a href="#" class="sortlink{% if sort == col %} active{% endif %}"
+  │     data-sort="{{ col }}" data-order="{% if sort == col and order == 'desc' %}asc{% else
+  │     %}desc{% endif %}">{{ label }}{% if sort == col %} {{ "↓" if order == "desc" else "↑" }}{%
+  │     endif %}</a>
+  │     21:           </th>
+  │     22:           {% endfor %}
+  │     23:         </tr>
+  │     24:       </thead>
+  │     25:       <tbody>
+  │     26:       {% for p in procs %}
+  │     27:         <tr>
+  │     28:           <td class="mono">{{ p.pid }}</td>
+  │     29:           <td class="pname" title="{{ p.name }}">{{ p.name }}</td>
+  │     30:           <td class="muted">{{ p.user }}</td>
+  │     31:           <td class="num">{{ p.cpu | round(1) }}</td>
+  │     32:           <td class="num">{{ p.mem_pct | round(1) }}</td>
+  │     33:           <td class="num">{{ p.rss | humanize }}</td>
+  │     34:           <td class="num">{% if p.gpu is not none %}{{ p.gpu }} MB{% else %}<span
+  │     class="muted">&mdash;</span>{% endif %}</td>
+  │     35:
+  │     … [348 more chars]
+  │
+  │ tokens 2352 in 224 out 6082 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:54:15 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ What I currently have:
+  │ - Complete index.html
+  │ - Complete app.js
+  │ - overview.html, disks.html, processes.html
+  │ - Directory listings
+  │
+  │ Next, I'll check the tab-related endpoints and CSS (for the .hidden and .tab-btn classes) in the
+  │ router. In addition, I'll also read a few more templates: services.html (to check the
+  │ accordion's htmx setup), journal.html, and plugins.html and the plugin's state templates (to
+  │ check per-plugin polling). I'll also check the tab-related endpoints in app/routers.
+  │
+  │ I'll read style.css and the remaining templates, and try grepping the router for tab-related
+  │ stuff.
+  │
+  │ I have the core files. Now let me check the CSS (for tab/hidden classes), the remaining
+  │ templates (services, journal, plugins), and the routers.
+  │
+  │ read /home/mac/Code/dashboard/static/css/style.css                                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/static/css/style.css"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/static/css/style.css</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: :root {
+  │     2:   --bg: #0e1116;
+  │     3:   --bg-panel: #161b23;
+  │     4:   --bg-card: #1c2330;
+  │     5:   --border: #2a3342;
+  │     6:   --text: #dbe2ea;
+  │     7:   --muted: #7d8a9c;
+  │     8:   --accent: #4fc3f7;
+  │     9:   --ok: #66bb6a;
+  │     10:   --warn: #ffb74d;
+  │     11:   --err: #ef5350;
+  │     12:   --busy: #fff176;
+  │     13: }
+  │     14:
+  │     15: * { box-sizing: border-box; }
+  │     16:
+  │     17: html, body {
+  │     18:   margin: 0;
+  │     19:   padding: 0;
+  │     20:   background: var(--bg);
+  │     21:   color: var(--text);
+  │     22:   font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  │     23:   font-size: 14px;
+  │     24: }
+  │     25:
+  │     26: h1 { font-size: 18px; margin: 0; }
+  │     27: h2 { font-size: 15px; margin: 18px 0 8px; }
+  │     28: h3 { font-size: 14px; margin: 0 0 8px; }
+  │     29: h4 { font-size: 13px; margin: 14px 0 6px; }
+  │     30: .mono { font-family: ui-monospace, "Cascadia Mono", Consolas, monospace; font-size:
+  │     12.5px; }
+  │     31: .muted { color: var(--muted); }
+  │     32: .small { font-size: 12px; }
+  │     33: .num { text-align: right; font-variant-numeric: tabular-nums; }
+  │     34:
+  │     35: .topbar {
+  │     36:   display: flex;
+  │     37:   align-items: center;
+  │     38:   gap: 24px;
+  │     39:   padding: 10px 16px;
+  │     40:   background: var(--bg-panel);
+  │     41:   border-bottom: 1px solid var(--border);
+  │     42:   position: sticky;
+  │     43:   top: 0;
+  │     44:   z-index: 10;
+  │     45:   flex-wrap: wrap;
+  │     46: }
+  │     47:
+  │     48: #tabs { display: flex; gap: 4px; flex-wrap: wrap; }
+  │     49:
+  │     50: .tab-btn {
+  │     51:   background: transparent;
+  │     52:   color: var(--muted);
+  │     53:   border: 1px solid transparent;
+  │     54:   padding: 6px 12px;
+  │     55:   border-radius: 6px;
+  │     56:   cursor: pointer;
+  │     57:   font-size: 13.5px;
+  │     58: }
+  │     59: .tab-btn:hover { color: var(--text); background: var(--bg-card); }
+  │     60: .tab-btn.active {
+  │     61:   color: var(--text);
+  │     62:   background: var(--bg-card);
+  │     63:   border-color: var(--border);
+  │     64: }
+  │     65:
+  │     66: main { padding: 14px 16px 40px; max-width: 1500px; margin: 0 auto; }
+  │     67: .hidden { display: none !important; }
+  │     68:
+  │     69: .panel {
+  │     70:   background: var(--bg-panel);
+  │     71:   border: 1px solid var(--border);
+  │     72:
+  │     … [8848 more chars]
+  │ read /home/mac/Code/dashboard/templates/services.html                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/services.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/services.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div id="services" class="panel" hx-get="/api/services" hx-trigger="every 15s"
+  │     hx-swap="outerHTML" hx-include="#svc-filters">
+  │     2:   {% if error %}<div class="alert">{{ error }}</div>{% endif %}
+  │     3:   <div class="muted small">system: {{ state }} &middot; {{ units | length }} units</div>
+  │     4:   <div class="table-wrap">
+  │     5:     <table class="table">
+  │     6:       <colgroup>
+  │     7:         <col style="width: 30px">
+  │     8:         <col style="width: 250px">
+  │     9:         <col>
+  │     10:         <col style="width: 130px">
+  │     11:         <col style="width: 90px">
+  │     12:         <col style="width: 190px">
+  │     13:       </colgroup>
+  │     14:       <thead>
+  │     15:         <tr>
+  │     16:           <th></th>
+  │     17:           <th><a href="#" class="sortlink{% if sort == "name" %} active{% endif %}"
+  │     data-form="svc-filters" data-sort="name" data-order="{% if sort == "name" and order == "asc"
+  │     %}desc{% else %}asc{% endif %}">Unit{% if sort == "name" %} {{ "↓" if order == "desc" else
+  │     "↑" }}{% endif %}</a></th>
+  │     18:           <th class="muted">Description</th>
+  │     19:           <th><a href="#" class="sortlink{% if sort == "state" %} active{% endif %}"
+  │     data-form="svc-filters" data-sort="state" data-order="{% if sort == "state" and order ==
+  │     "asc" %}desc{% else %}asc{% endif %}">State{% if sort == "state" %} {{ "↓" if order ==
+  │     "desc" else "↑" }}{% endif %}</a></th>
+  │     20:           <th><a href="#" class="sortlink{% if sort == "enabled" %} active{% endif %}"
+  │     data-form="svc-filters" data-sort="enabled" data-order="{% if sort == "enabled" and order ==
+  │     "asc" %}desc{% else %}asc{% endif %}">Enabled{% if sort == "enabled" %} {{ "↓" if order ==
+  │     "desc" else "↑" }}{% endif %}</a></th>
+  │     21:           <th>Actions</th>
+  │     22:         </tr>
+  │     23:       </thead>
+  │     24:       <tbody>
+  │     25:       {% for u in units %}
+  │     26:         {% set dot = "dot-dead" %}
+  │     27:         {% if u.sub in ("running", "exited") and u.active == "active" %}{% set dot =
+  │     "dot-run" %}{% endif %}
+  │     28:         {% if u
+  │     … [2353 more chars]
+  │ read /home/mac/Code/dashboard/templates/journal.html                                 ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/journal.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/journal.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: {% if error %}
+  │     2: <div class="jline j-error-once"><span class="muted">journalctl: {{ error }}</span></div>
+  │     3: {% endif %}
+  │     4: {% for e in entries %}
+  │     5: <div class="jline{% if e.prio <= 3 %} j-err{% elif e.prio == 4 %} j-warn{% endif %}"
+  │     data-cursor="{{ e.cursor }}">
+  │     6:   <span class="j-time">{{ e.stamp }}</span>
+  │     7:   <span class="j-ident">{{ e.ident }}</span>
+  │     8:   <span class="j-msg">{{ e.msg }}</span>
+  │     9: </div>
+  │     10: {% endfor %}
+  │
+  │     (End of file - total 10 lines)
+  │     </content>
+  │ 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:   {% for item in items %}
+  │     3:   <div class="plugin-card">
+  │     4:     <h3>{{ item.p.title }}</h3>
+  │     5:     <p class="muted small">{{ item.p.description }}</p>
+  │     6:     <div class="plugin-body">{{ item.body | safe }}</div>
+  │     7:   </div>
+  │     8:   {% else %}
+  │     9:   <div class="muted">no plugins registered</div>
+  │     10:   {% endfor %}
+  │     11: </div>
+  │
+  │     (End of file - total 11 lines)
+  │     </content>
+  │
+  │ tokens 6608 in 302 out 8658 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:54:34 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ Next, let's check the routers to see if there are any tab-related endpoints. Also, let's check
+  │ the plugin's state templates to see if there's any per-plugin polling. I'll look at the routers
+  │ and plugin templates, and also check main.py for the route definitions.
+  │
+  │ Now let me examine the routers and the plugin state templates to complete the picture.
+  │
+  │ grep tab|@router\.|@app\.                                                            ok     0.0s
+  │   in
+  │     {
+  │       "pattern": "tab|@router\\.|@app\\.",
+  │       "path": "/home/mac/Code/dashboard/app",
+  │       "include": "*.py"
+  │     }
+  │   out
+  │     Found 38 matches
+  │     /home/mac/Code/dashboard/app/journal.py:
+  │       Line 42:     """Reduce raw export entries to the fields the journal tab renders.
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/sessions.py:
+  │       Line 48:     """Shape loginctl session entries into table rows for the UI.
+  │
+  │       Line 125: @router.get("/state")
+  │
+  │       Line 131: @router.post("/terminate")
+  │
+  │
+  │     /home/mac/Code/dashboard/app/main.py:
+  │       Line 58:     The shell only holds the tab bar and containers; each tab polls its
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:
+  │       Line 192: @router.get("/state")
+  │
+  │       Line 198: @router.post("/load")
+  │
+  │       Line 217: @router.post("/unload")
+  │
+  │       Line 236: @router.post("/rescan")
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/sleep.py:
+  │       Line 63:     """Shape block-mode inhibitor entries into table rows for the UI.
+  │
+  │       Line 218: @router.get("/state")
+  │
+  │       Line 224: @router.post("/toggle")
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/lact.py:
+  │       Line 185: @router.get("/state")
+  │
+  │       Line 191: @router.post("/set")
+  │
+  │       Line 225: @router.post("/reload")
+  │
+  │
+  │     /home/mac/Code/dashboard/app/routers/services.py:
+  │       Line 100: @router.get("")
+  │
+  │       Line 102:     """Render the Services tab fragment.
+  │
+  │       Line 115: @router.get("/{unit}/detail")
+  │
+  │       Line 144: @router.post("/{unit}/action")
+  │
+  │
+  │     /home/mac/Code/dashboard/app/collect/cpu.py:
+  │       Line 21:         The sysfs file to read, or None if no suitable sensor exists.
+  │
+  │
+  │     /home/mac/Code/dashboard/app/plugins/base.py:
+  │       Line 1: from collections.abc import Awaitable, Callable
+  │
+  │       Line 12:     renders the plugin's initial fragment for the Plugins tab.
+  │
+  │       Line 18:     skeleton_fn: Callable[[], Awaitable[str]] | None = field(default=None)
+  │
+  │       Line 19:     open_fn: Callable[[], Awaitable[None]] | None = field(default=None)
+  │
+  │       Line 20:     close_fn: Callable[[], Awaitable[None]] | None = field(default=None)
+  │
+  │       Line 26:             The HTML fragment for the Plugins tab.
+  │
+  │
+  │     /home/mac/Code/dashboard/app/routers/overview.py:
+  │       Line 19: @router.get("/overview")
+  │
+  │       Line 21:     """Render the Overview tab fr
+  │     … [881 more chars]
+  │ read /home/mac/Code/dashboard/templates/plugins/sleep_state.html                     ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sleep_state.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/sleep_state.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: {% if error %}<div class="alert">systemd-inhibit failed: {{ error }}</div>{% endif %}
+  │     2: {% if message %}<div class="notice">{{ message }}</div>{% endif %}
+  │     3: <div class="llama-health">
+  │     4:   <span class="dot {{ "dot-failed" if verdict == "blocked" else "dot-run" }}"></span>
+  │     5:   <span class="llama-health-text">{{ "sleep blocked" if verdict == "blocked" else "sleep
+  │     allowed" }}</span>
+  │     6:   <span class="muted small">block-mode locks only — delay-mode locks are ignored</span>
+  │     7: </div>
+  │     8: <label class="chk">
+  │     9:   <input type="checkbox" name="on" value="1" {% if holding %}checked{% endif %}
+  │     hx-post="/api/plugins/sleep/toggle" hx-target="closest .plugin-body" hx-swap="innerHTML">
+  │     10:   keep system awake (this dashboard holds a sleep lock)
+  │     11: </label>
+  │     12: {% if inhibitors %}
+  │     13: <div class="table-wrap">
+  │     14: <table class="table">
+  │     15:   <thead><tr><th>who</th><th>what</th><th>why</th><th>mode</th></tr></thead>
+  │     16:   <tbody>
+  │     17:     {% for e in inhibitors %}
+  │     18:     <tr class="{{ "inh-own" if e.own else "" }}">
+  │     19:       <td class="cell-clip">{{ e.who }}{% if e.proc %} <span class="muted small mono">{{
+  │     e.proc }}</span>{% endif %}</td>
+  │     20:       <td>{% for w in e.what.split(":") if w %}<span class="badge">{{ w }}</span> {%
+  │     endfor %}</td>
+  │     21:       <td class="cell-clip muted">{{ e.why }}</td>
+  │     22:       <td><span class="badge {{ "badge-block" if e.mode == "block" else "" }}">{{ e.mode
+  │     }}</span></td>
+  │     23:     </tr>
+  │     24:     {% endfor %}
+  │     25:   </tbody>
+  │     26: </table>
+  │     27: </div>
+  │     28: {% else %}
+  │     29: <div class="muted small">no active block-mode inhibitors — the system may sleep</div>
+  │     30: {% endif %}
+  │
+  │     (End of file - total 30 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/llamacpp_state.html                  ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_state.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/llamacpp_state.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: {% if not reachable %}
+  │     2: <div class="alert">llama-server unreachable at <span class="mono">{{ base_url }}</span>{%
+  │     if error %}: {{ error }}{% endif %}</div>
+  │     3: <div class="muted small">start it in router mode: <span class="mono">llama-server
+  │     --models-dir /path/to/models</span></div>
+  │     4: {% else %}
+  │     5: <div class="llama-health">
+  │     6:   <span class="dot {{ "dot-run" if health == "ok" else "dot-failed" }}"></span>
+  │     7:   <span class="llama-health-text">{{ "healthy" if health == "ok" else (health or "status
+  │     unknown") }}</span>
+  │     8:   <span class="muted small mono">{{ base_url }}</span>
+  │     9: </div>
+  │     10: {% if message %}<div class="notice">{{ message }}</div>{% endif %}
+  │     11: {% if error_msg %}<div class="alert">{{ error_msg }}</div>{% endif %}
+  │     12:
+  │     13: <h4>Loaded models</h4>
+  │     14: {% if loaded %}
+  │     15: <div class="llama-models">
+  │     16:   {% for m in loaded %}
+  │     17:   <div class="llama-model">
+  │     18:     <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>
+  │     19:     <span class="mono llama-id" title="{{ m.path }}">{{ m.id }}</span>
+  │     20:     <span class="badge badge-{{ "failed" if m.failed else m.state }}">{{ m.state }}{% if
+  │     m.failed %} (exit {{ m.exit_code }}){% endif %}</span>
+  │     21:     {% if m.progress is not none %}<div class="bar small-bar"><div class="bar-fill"
+  │     style="width: {{ m.progress }}%"></div></div>{% endif %}
+  │     22:     <span class="llama-model-actions">
+  │     23:       <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>
+  │     24:     </span>
+  │     25:   </div>
+  │     26:   {% endfor %}
+  │     27: </div>
+  │     28: {% else %}
+  │     29: <div class="muted small">no models loaded</div>
+  │     30: {% endif %}
+  │     31: {% endif %}
+  │
+  │     (End of file - total 31 lines)
+  │     </content>
+  │
+  │ tokens 6777 in 212 out 15568 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:54:52 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ Let me check main.py to see how the routes are registered, and also check the router's
+  │ __init__.py to understand the URL structure. I also want to verify how the plugin tab works —
+  │ plugins.html has `hx-get="/api/plugins" hx-trigger="load"`, and the individual plugin skeletons
+  │ might have their own polling. Let me check the skeleton templates.
+  │
+  │ Let me check main.py, the router registration, and the plugin skeleton templates (to see
+  │ per-plugin polling).
+  │
+  │ read /home/mac/Code/dashboard/app/main.py                                            ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/main.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/main.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: import asyncio
+  │     2: import socket
+  │     3: from contextlib import asynccontextmanager
+  │     4:
+  │     5: from fastapi import FastAPI
+  │     6: from fastapi.responses import HTMLResponse
+  │     7: from fastapi.staticfiles import StaticFiles
+  │     8:
+  │     9: from app.config import get_settings
+  │     10: from app.plugins import PLUGINS, ROUTERS as PLUGIN_ROUTERS
+  │     11: from app.render import BASE, render
+  │     12: from app.routers import disks, overview, plugins, processes, services
+  │     13: from app.routers import journal as journal_router
+  │     14: from app.sampling import sampler_loop
+  │     15: from app.state import HistoryStore
+  │     16:
+  │     17:
+  │     18: @asynccontextmanager
+  │     19: async def lifespan(app: FastAPI):
+  │     20:     """Start shared state and run plugin lifecycle hooks around the app.
+  │     21:
+  │     22:     Startup: stores settings and the history ring buffer on `app.state`,
+  │     23:     opens every plugin (a plugin `open()` failure is ignored, not fatal),
+  │     24:     and spawns the background sampler task. Shutdown: cancels the
+  │     25:     sampler task and closes every plugin.
+  │     26:
+  │     27:     Args:
+  │     28:         app: the FastAPI instance.
+  │     29:
+  │     30:     Yields:
+  │     31:         Control to the ASGI app for the server's lifetime.
+  │     32:     """
+  │     33:     settings = get_settings()
+  │     34:     app.state.settings = settings
+  │     35:     app.state.store = HistoryStore(maxlen=settings.history_maxlen)
+  │     36:     for p in PLUGINS:
+  │     37:         try:
+  │     38:             await p.open()
+  │     39:         except Exception: # noqa
+  │     40:             pass
+  │     41:     task = asyncio.create_task(sampler_loop(app.state.store, settings.sample_interval))
+  │     42:     yield
+  │     43:     _ = task.cancel()
+  │     44:     try:
+  │     45:         await task
+  │     46:     except asyncio.CancelledError:
+  │     47:         pass
+  │     48:     for p in PLUGINS:
+  │     49:         try:
+  │     50:             await p.close()
+  │     51:         except Exception: # noqa
+  │     52:             pass
+  │     53:
+  │     54:
+  │     55: async def index():
+  │     56:     """Serve the single-page dashboard shell at "/".
+  │     57:
+  │     58:     The shell only holds the tab bar and contai
+  │     … [1182 more chars]
+  │ read /home/mac/Code/dashboard/app/routers/__init__.py                                ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/app/routers/__init__.py"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/app/routers/__init__.py</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: from app.routers import disks, journal, overview, plugins, processes, services
+  │     2:
+  │     3: __all__ = ["overview", "disks", "processes", "journal", "services", "plugins"]
+  │
+  │     (End of file - total 3 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/lact_skeleton.html                   ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/lact_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/lact_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="lact">
+  │     2:   <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/lact_state.html" %}
+  │     4:   </div>
+  │     5:   {% if gpus and not error %}
+  │     6:   {% for g in gpus %}
+  │     7:   <div class="lact-load">
+  │     8:     <select id="lact-pick-{{ g.id }}" name="profile">
+  │     9:       {% for p in g.profiles %}
+  │     10:       <option value="{{ p }}" {{ "selected" if p == g.active }}>{{ p }}{% if p ==
+  │     g.active %} (active){% endif %}</option>
+  │     11:       {% else %}
+  │     12:       <option value="" disabled selected>no profiles</option>
+  │     13:       {% endfor %}
+  │     14:     </select>
+  │     15:     <span class="actions">
+  │     16:       <button class="btn" hx-post="/api/plugins/lact/set" hx-vals='{"gpu_id":"{{ g.id
+  │     }}"}' hx-include="#lact-pick-{{ g.id }}" hx-target="closest .plugin-body"
+  │     hx-swap="innerHTML">set</button>
+  │     17:       <button class="btn" hx-post="/api/plugins/lact/reload" hx-vals='{"gpu_id":"{{ g.id
+  │     }}"}' hx-target="closest .plugin-body" hx-swap="innerHTML">reload</button>
+  │     18:     </span>
+  │     19:   </div>
+  │     20:   {% endfor %}
+  │     21:   {% endif %}
+  │     22: </div>
+  │
+  │     (End of file - total 22 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/llamacpp_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="llama">
+  │     2:   <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/llamacpp_state.html" %}
+  │     4:   </div>
+  │     5:   {% if reachable %}
+  │     6:   <h4>Available models</h4>
+  │     7:   {% if available %}
+  │     8:   <div class="llama-load">
+  │     9:     <select id="llama-model-pick" name="model">
+  │     10:       {% for m in available %}
+  │     11:       <option value="{{ m.id }}">{{ m.id }}{% if m.failed %} (failed, exit {{
+  │     m.exit_code }}){% endif %}</option>
+  │     12:       {% endfor %}
+  │     13:     </select>
+  │     14:     <button class="btn" hx-post="/api/plugins/llamacpp/load"
+  │     hx-include="#llama-model-pick" hx-target="closest .plugin-body"
+  │     hx-swap="innerHTML">load</button>
+  │     15:   </div>
+  │     16:   {% else %}
+  │     17:   <div class="muted small">no unloaded models (is --models-dir set on the server?)</div>
+  │     18:   {% endif %}
+  │     19:
+  │     20:   <div class="actions">
+  │     21:     <button class="btn" hx-post="/api/plugins/llamacpp/rescan" hx-target="closest
+  │     .plugin-body" hx-swap="innerHTML">rescan models</button>
+  │     22:   </div>
+  │     23:   {% endif %}
+  │     24: </div>
+  │
+  │     (End of file - total 24 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html               ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/sessions_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="sessions">
+  │     2:   <div id="sessions-state" hx-get="/api/plugins/sessions/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/sessions_state.html" %}
+  │     4:   </div>
+  │     5: </div>
+  │
+  │     (End of file - total 5 lines)
+  │     </content>
+  │ read /home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html                  ok     0.0s
+  │   in
+  │     {
+  │       "filePath": "/home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html"
+  │     }
+  │   out
+  │     <path>/home/mac/Code/dashboard/templates/plugins/sleep_skeleton.html</path>
+  │     <type>file</type>
+  │     <content>
+  │     1: <div class="sleep">
+  │     2:   <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="every 5s"
+  │     hx-swap="innerHTML">
+  │     3:     {% include "plugins/sleep_state.html" %}
+  │     4:   </div>
+  │     5: </div>
+  │
+  │     (End of file - total 5 lines)
+  │     </content>
+  │
+  │ tokens 2148 in 314 out 22556 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:55:05 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ Now I have a very complete overall picture. Let me do one more check at the end: verify that no
+  │ other .js files exist (only app.js and the vendor files), and check the plugins router to see
+  │ how /api/plugins renders the skeletons. Also, quickly verify the route paths of each router to
+  │ document the endpoints. For the sake of accuracy, let me read the plugins router and skim
+  │ through the route definitions of the routers.
+  │
+  │ Let me verify the plugins router and get exact route paths from all routers.
+  │
+  │ 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:     """Render the Plugins tab: a skeleton fragment for every registered plugin.
+  │     13:
+  │     14:     A plugin whose skeleton() raises gets an inline error card instead of
+  │     15:     taking down the whole page.
+  │     16:
+  │     17:     Returns:
+  │     18:         The rendered plugins.html as an HTMLResponse.
+  │     19:     """
+  │     20:     items: list[dict[str, Plugin | str]] = []
+  │     21:     for p in PLUGINS:
+  │     22:         try:
+  │     23:             body = await p.skeleton()
+  │     24:         except Exception as e: # noqa
+  │     25:             body = f"<div class='alert'>plugin error: {e}</div>"
+  │     26:         items.append({"p": p, "body": body})
+  │     27:     return HTMLResponse(render("plugins.html", items=items))
+  │
+  │     (End of file - total 27 lines)
+  │     </content>
+  │ bash rg -n "APIRouter\(|@router\.(get|post)" /home/mac/Code/dashboard/app/routers…   ok     0.0s
+  │   in
+  │     {
+  │       "command": "rg -n \"APIRouter\\(|@router\\.(get|post)\"
+  │       /home/mac/Code/dashboard/app/routers/ /home/mac/Code/dashboard/app/plugins/"
+  │     }
+  │   out
+  │     /home/mac/Code/dashboard/app/plugins/sessions.py:12:router =
+  │     APIRouter(prefix="/api/plugins/sessions", tags=["plugins"])
+  │     /home/mac/Code/dashboard/app/plugins/sessions.py:125:@router.get("/state")
+  │     /home/mac/Code/dashboard/app/plugins/sessions.py:131:@router.post("/terminate")
+  │     /home/mac/Code/dashboard/app/routers/services.py:10:router =
+  │     APIRouter(prefix="/api/services", tags=["services"])
+  │     /home/mac/Code/dashboard/app/routers/services.py:100:@router.get("")
+  │     /home/mac/Code/dashboard/app/routers/services.py:115:@router.get("/{unit}/detail")
+  │     /home/mac/Code/dashboard/app/routers/services.py:144:@router.post("/{unit}/action")
+  │     /home/mac/Code/dashboard/app/plugins/sleep.py:13:router =
+  │     APIRouter(prefix="/api/plugins/sleep", tags=["plugins"])
+  │     /home/mac/Code/dashboard/app/plugins/sleep.py:218:@router.get("/state")
+  │     /home/mac/Code/dashboard/app/plugins/sleep.py:224:@router.post("/toggle")
+  │     /home/mac/Code/dashboard/app/plugins/lact.py:14:router =
+  │     APIRouter(prefix="/api/plugins/lact", tags=["plugins"])
+  │     /home/mac/Code/dashboard/app/plugins/lact.py:185:@router.get("/state")
+  │     /home/mac/Code/dashboard/app/plugins/lact.py:191:@router.post("/set")
+  │     /home/mac/Code/dashboard/app/plugins/lact.py:225:@router.post("/reload")
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:11:router =
+  │     APIRouter(prefix="/api/plugins/llamacpp", tags=["plugins"])
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:192:@router.get("/state")
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:198:@router.post("/load")
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:217:@router.post("/unload")
+  │     /home/mac/Code/dashboard/app/plugins/llamacpp.py:236:@router.post("/rescan")
+  │     /home/mac/Code/dashboard/app/routers/journal.py:9:router = APIRouter(prefix="/api",
+  │     tags=["journal"])
+  │     /home/mac/Code/dashboard/app/routers/journal.py:12:@router.get("/journal")
+  │     /home/mac/Code/dashboard/app/routers/overview.py:16:router = APIRouter(prefix="/api",
+  │     tags=["overview"])
+  │     /home/mac/Code/dashboard/app/routers/overview.py:19:@router.get("/overview")
+  │     /h
+  │     … [605 more chars]
+  │
+  │ tokens 2187 in 201 out 25018 cached 0 written $0.0000 tool-calls
+
+
+  │ 2026-08-31 01:55:16 • assistant • Qwen3.8-27B-Think @explore
+  │
+  │ Now I have a grasp of the overall picture. Let me put together a thorough report.
+  │
+  │ Summary of the main investigation findings:
+  │
+  │ **File listing:**
+  │
+  │ templates/:
+  │ - disks.html (2013 bytes)
+  │ - index.html (4442 bytes)
+  │ - journal.html (404 bytes)
+  │ - overview.html (4057 bytes)
+  │ - plugins.html (326 bytes)
+  │ - processes.html (2052 bytes)
+  │ - service_detail.html (1112 bytes)
+  │ - services.html (4024 bytes)
+  │ - plugins/ (subdirectory):
+  │   - lact_skeleton.html
+  │   - lact_state.html
+  │   - llamacpp_skeleton.html
+  │   - llamacpp_state.html
+  │   - sessions_skeleton.html
+  │   - sessions_state.html
+  │   - sleep_skeleton.html
+  │   - sleep_state.html
+  │
+  │ static/:
+  │ - css/style.css (9441 bytes)
+  │ - js/app.js (8178 bytes)
+  │ - vendor/chart.umd.min.js (205125 bytes)
+  │ - vendor/htmx.min.js (48101 bytes)
+  │
+  │ **Tab system:**
+  │ - index.html has a `<nav id="tabs">`, with `<button class="tab-btn [active]" data-tab="...">`
+  │ buttons
+  │ - `<main>` has `<section id="tab-<name>" class="tab [hidden]">` sections
+  │ - Pure JS inside app.js (no htmx on the tab buttons): `showTab(name)` toggles the `.active`
+  │ class on the button and the `.hidden` class on the section
+  │ - The selected tab is persisted in localStorage under the key `dash.tab`
+  │ - CSS: `.tab-btn.active` styles, `.hidden { display: none !important; }`
+  │ - Key point: there's no pausing/resuming of polling on tab switch — all polling divs are inside
+  │ the DOM at all times, so htmx's `hx-trigger="load, every Ns"` continues polling all tabs even
+  │ while hidden. The plugins tab's state divs are only loaded after /api/plugins fetches the
+  │ skeleton (hx-trigger="load" on the #plugins div), and once loaded the every-5s polling of each
+  │ plugin state div continues regardless of visibility.
+  │
+  │ **Polling:**
+  │ - Overview panel: `/api/overview` every 2 seconds (load + every 2s in index; every 2s in the
+  │ fragment)
+  │ - Overview charts: plain JS `setInterval(pollHistory, 2000)` fetches `/api/history` (JSON) — not
+  │ htmx
+  │ - Disks: `/api/disks` every 2 seconds
+  │ - Processes: `/api/processes` every 3 seconds, includes `#proc-controls` (filter
+  │ … [3532 more chars]
+  │
+  │ I now have a complete picture of the tab system. Here is the thorough report.
+  │
+  │ # Dashboard Tab System — Full Analysis
+  │
+  │ ## 1. File Listings
+  │
+  │ ### `templates/` (absolute paths)
+  │ ```
+  │ /home/mac/Code/dashboard/templates/index.html          (4442 B) — SPA shell: tab bar + all
+  │ section containers
+  │ /home/mac/Code/dashboard/templates/overview.html       (4057 B) — Overview fragment (cards)
+  │ /home/mac/Code/dashboard/templates/disks.html          (2013 B) — Disks fragment
+  │ /home/mac/Code/dashboard/templates/processes.html      (2052 B) — Processes fragment
+  │ /home/mac/Code/dashboard/templates/journal.html        ( 404 B) — Journal fragment (line batch)
+  │ /home/mac/Code/dashboard/templates/services.html       (4024 B) — Services fragment
+  │ /home/mac/Code/dashboard/templates/service_detail.html (1112 B) — Service accordion detail
+  │ fragment
+  │ /home/mac/Code/dashboard/templates/plugins.html        ( 326 B) — Plugins fragment (wraps
+  │ skeletons)
+  │ /home/mac/Code/dashboard/templates/plugins/
+  │ ├── llamacpp_skeleton.html  ( 982 B)
+  │ ├── llamacpp_state.html     (1705 B)
+  │ ├── sleep_skeleton.html     ( 182 B)
+  │ ├── sleep_state.html        (1502 B)
+  │ ├── lact_skeleton.html      (1011 B)
+  │ ├── lact_state.html         ( 713 B)
+  │ └── sessions_skeleton.html  ( 194 B)
+  │     sessions_state.html     (1091 B)
+  │ ```
+  │
+  │ ### `static/` (exists)
+  │ ```
+  │ /home/mac/Code/dashboard/static/css/style.css          (9441 B)
+  │ /home/mac/Code/dashboard/static/js/app.js              (8178 B) — the only hand-written JS
+  │ /home/mac/Code/dashboard/static/vendor/htmx.min.js     (48101 B)
+  │ /home/mac/Code/dashboard/static/vendor/chart.umd.min.js(205125 B)
+  │ ```
+  │ No other `.js` files exist in the repo (verified by glob: only `app.js` + the two vendor libs).
+  │
+  │ ---
+  │
+  │ ## 2. Full Content of `templates/index.html` (the SPA shell)
+  │
+  │ ```html
+  │   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:         <option value="cpu">sort: CPU</option>
+  │  42:         <option value="rss">sort: MEM</option>
+  │  43:         <option value="mem_pct">sort: MEM%</option>
+  │  44:         <option value="io_read">sort: IO read</option>
+  │  45:         <option value="io_write">sort: IO write</option>
+  │  46:         <option value="pid">sort: PID</option>
+  │  47:         <option value="name">sort: Name</option>
+  │  48:       </select>
+  │  49:       <select name="order" id="proc-order">
+  │  50:         <option value="desc">desc</option>
+  │  51:         <option value="asc">asc</option>
+  │  52:       </select>
+  │  53:       <button type="submit">apply</button>
+  │  54:     </form>
+  │  55:     <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="load, every
+  │  3s" hx-swap="outerHTML" hx-include="#proc-controls"></div>
+  │  56:   </section>
+  │  57:
+  │  58:   <section id="tab-journal" class="tab hidden">
+  │  59:     <div id="journal-status" class="muted small"></div>
+  │  60:     <form id="journal-filters" class="inline-form" hx-get="/api/journal"
+  │  hx-target="#journal-log" hx-swap="innerHTML">
+  │  61:       <select name="level">
+  │  62:         <option value="all">all</option>
+  │  63:         <option value="warn">warn+</option>
+  │  64:         <option value="err">err+</option>
+  │  65:       </select>
+  │  66:       <input name="unit" placeholder="unit (ssh.service)">
+  │  67:       <input name="search" placeholder="search text">
+  │  68:       <label class="chk"><input type="checkbox" name="hide_sudo" checked> hide sudo</label>
+  │  69:       <button type="submit">filter</button>
+  │  70:     </form>
+  │  71:     <div id="journal-logwrap">
+  │  72:       <input type="hidden" id="journal-cursor" name="cursor" value="">
+  │  73:       <div id="journal-log" hx-get="/api/journal" hx-trigger="load, every 5s"
+  │  hx-swap="beforeend" hx-include="#journal-filters, #journal-cursor"></div>
+  │  74:     </div>
+  │  75:   </section>
+  │  76:
+  │  77:   <section id="tab-services" class="tab hidden">
+  │  78:     <form id="svc-filters" class="inline-form" hx-get="/api/services" hx-target="#services"
+  │  hx-swap="outerHTML">
+  │  79:       <input id="svc-q" name="q" placeholder="filter units">
+  │  80:       <select name="sort" id="svc-sort">
+  │  81:         <option value="name">sort: name</option>
+  │  82:         <option value="state">sort: state</option>
+  │  83:         <option value="enabled">sort: enabled</option>
+  │  84:       </select>
+  │  85:       <select name="order" id="svc-order">
+  │  86:         <option value="asc">asc</option>
+  │  87:         <option value="desc">desc</option>
+  │  88:       </select>
+  │  89:       <button type="submit">filter</button>
+  │  90:     </form>
+  │  91:     <div id="services" class="panel" hx-get="/api/services" hx-trigger="load, every 15s"
+  │  hx-swap="outerHTML" hx-include="#svc-filters"></div>
+  │  92:   </section>
+  │  93:
+  │  94:   <section id="tab-plugins" class="tab hidden">
+  │  95:     <div id="plugins" class="panel" hx-get="/api/plugins" hx-trigger="load"
+  │  hx-swap="outerHTML"></div>
+  │  96:   </section>
+  │  97: </main>
+  │  98: <script src="/static/js/app.js"></script>
+  │  99: </body>
+  │ 100: </html>
+  │ ```
+  │
+  │ Structural pattern: one `<button class="tab-btn" data-tab="X">` per tab in `nav#tabs`; one
+  │ `<section id="tab-X" class="tab [hidden]">` per tab in `<main>`. All six sections are present in
+  │ the DOM from the start, and **every section's polling div is live from page load regardless of
+  │ which tab is visible** (no htmx pausing on hidden elements).
+  │
+  │ ---
+  │
+  │ ## 3. Tab Switching Mechanism (exact)
+  │
+  │ **It is NOT htmx.** The tab buttons carry no `hx-*` attributes. Switching is plain JavaScript in
+  │ `static/js/app.js`, lines 4–19:
+  │
+  │ ```js
+  │  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) {}
+  │ ```
+  │
+  │ Mechanism, precisely:
+  │ 1. Click on any `.tab-btn` → `showTab(b.dataset.tab)`.
+  │ 2. `showTab` toggles `.active` on the single matching button and `.hidden` on the single
+  │ matching `#tab-<name>` section.
+  │ 3. The chosen tab name is persisted to `localStorage["dash.tab"]`; on page load, if that section
+  │ exists, it is restored (lines 16–19).
+  │ 4. The server never knows the active tab — `app/main.py` `index()` renders the shell once
+  │ ("renders once and never again", line 59) and no endpoint accepts a tab parameter.
+  │
+  │ CSS support in `static/css/style.css`:
+  │ ```css
+  │  48: #tabs { display: flex; gap: 4px; flex-wrap: wrap; }
+  │  50: .tab-btn {
+  │  51:   background: transparent;
+  │  52:   color: var(--muted);
+  │  53:   border: 1px solid transparent;
+  │  54:   padding: 6px 12px;
+  │  55:   border-radius: 6px;
+  │  56:   cursor: pointer;
+  │  57:   font-size: 13.5px;
+  │  58: }
+  │  59: .tab-btn:hover { color: var(--text); background: var(--bg-card); }
+  │  60: .tab-btn.active {
+  │  61:   color: var(--text);
+  │  62:   background: var(--bg-card);
+  │  63:   border-color: var(--border);
+  │  64: }
+  │  ...
+  │  66: main { padding: 14px 16px 40px; max-width: 1500px; margin: 0 auto; }
+  │  67: .hidden { display: none !important; }
+  │ ```
+  │ So `.hidden` is a global utility (`display: none !important`), and `.active` is the only state
+  │ class on buttons. No URL/hash/`history.pushState` involvement.
+  │
+  │ ---
+  │
+  │ ## 4. Representative Tab Templates (full content, showing polling)
+  │
+  │ ### `templates/overview.html` — self-polling fragment, `outerHTML` swap
+  │ ```html
+  │  1: <div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="every 2s"
+  │  hx-swap="outerHTML">
+  │  2:   {% macro bar(pct) %}{% if pct is not none %}<div class="bar"><div class="bar-fill{% if pct
+  │  > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct }}%"></div></div>{% endif
+  │  %}{% endmacro %}
+  │  3:   {% macro barrow(label, pct, cls) %}{% if pct is not none %}<div class="barrow"><span
+  │  class="barrow-label">{{ label }}</span><div class="bar"><div class="bar-fill{% if cls %} {{ cls
+  │  }}{% endif %}{% if pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct
+  │  }}%"></div></div></div>{% endif %}{% endmacro %}
+  │  4:   <div class="card">
+  │  5:     <div class="card-label">CPU / GPU</div>
+  │  6:     <div class="card-value">{{ (c.cpu | default(0, true)) | round(1) }}%</div>
+  │  7:     {{ barrow("CPU", c.cpu) }}
+  │  8:     {{ barrow("GPU", c.gpu, "gpu") }}
+  │  9:     {% if c.cpu_temp is not none or c.gpu_temp is not none %}
+  │ 10:       <div class="card-sub">
+  │ 11:         {% if c.cpu_temp is not none %}CPU {{ c.cpu_temp | round(0) | int }}&deg;C{% endif
+  │ %}
+  │ 12:         {% if c.cpu_temp is not none and c.gpu_temp is not none %} &middot;{% endif %}
+  │ 13:         {% if c.gpu_temp is not none %}GPU {{ c.gpu_temp | round(0) | int }}&deg;C{% endif
+  │ %}
+  │ 14:       </div>
+  │ 15:     {% endif %}
+  │ 16:     <div class="card-sub">load {{ (c.load1 | default(0, true)) | round(2) }} &middot; {{
+  │ c.cores }} cores</div>
+  │ 17:   </div>
+  │ 18:   <div class="card">
+  │ 19:     <div class="card-label">Memory</div>
+  │ 20:     <div class="card-value">{{ c.mem_used | humanize }} <span class="muted">/ {{ c.mem_total
+  │ | humanize }} ({{ (c.mem_pct | default(0, true)) | round(0) | int }}%)</span></div>
+  │ 21:     {{ bar(c.mem_pct) }}
+  │ 22:     <div class="memrow">
+  │ 23:       <div class="memrow-text">Swap {% if c.swap_total %}{{ c.swap_used | humanize }} <span
+  │ class="muted">/ {{ c.swap_total | humanize }} ({{ (c.swap_pct | default(0, true)) | round(0) |
+  │ int }}%)</span>{% else %}<span class="muted">none</span>{% endif %}</div>
+  │ 24:       {{ bar(c.swap_pct if c.swap_total else none) }}
+  │ 25:     </div>
+  │ 26:     <div class="memrow">
+  │ 27:       <div class="memrow-text">VRAM {% if c.vram_total %}{{ c.vram_used | humanize }} <span
+  │ class="muted">/ {{ c.vram_total | humanize }} ({{ (c.vram_pct | default(0, true)) | round(0) |
+  │ int }}%)</span>{% else %}<span class="muted">&mdash;</span>{% endif %}</div>
+  │ 28:       {{ bar(c.vram_pct if c.vram_total else none) }}
+  │ 29:     </div>
+  │ 30:   </div>
+  │ 31:   {% if c.battery is not none %}
+  │ 32:   <div class="card">
+  │ 33:     <div class="card-label">Battery</div>
+  │ 34:     <div class="card-value">{{ c.battery }}%</div>
+  │ 35:     <div class="bar"><div class="bar-fill{% if c.battery < 20 %} low{% elif c.battery < 45
+  │ %} warm{% endif %}" style="width: {{ c.battery }}%"></div></div>
+  │ 36:     {% if c.ac_online is not none %}
+  │ 37:       <div class="card-sub">
+  │ 38:         {% if c.ac_online %}on AC{% else %}on battery{% endif %}
+  │ 39:         {% set st = (c.battery_status or "") | lower %}
+  │ 40:         {% if st == "charging" %} &middot; charging{% elif c.ac_online and st in ("full",
+  │ "not charging") %} &middot; full{% endif %}
+  │ 41:       </div>
+  │ 42:     {% endif %}
+  │ 43:   </div>
+  │ 44:   {% endif %}
+  │ 45:   <div class="card">
+  │ 46:     <div class="card-label">Network</div>
+  │ 47:     {% if c.net_wifi and c.net_wifi.ssid %}
+  │ 48:       <div class="card-value">{{ c.net_wifi.ssid }}</div>
+  │ 49:       <div class="card-sub">Wi-Fi via {{ c.net_wifi.iface }}</div>
+  │ 50:     {% elif c.net_wifi %}
+  │ 51:       <div class="card-value muted">Wi-Fi</div>
+  │ 52:       <div class="card-sub">{{ c.net_wifi.iface }} &middot; no connection</div>
+  │ 53:     {% elif c.net_ifaces %}
+  │ 54:       <div class="card-value muted">wired</div>
+  │ 55:     {% else %}
+  │ 56:       <div class="card-value muted">&mdash;</div>
+  │ 57:     {% endif %}
+  │ 58:     <div class="card-sub">
+  │ 59:       {% for i in c.net_ifaces %}
+  │ 60:         <div class="mono small">{{ i.name }}: {% if i.ipv4 %}{{ i.ipv4 | join(", ") }}{%
+  │ else %}<span class="muted">no IPv4</span>{% endif %}</div>
+  │ 61:       {% else %}
+  │ 62:         <span class="muted">no active interfaces</span>
+  │ 63:       {% endfor %}
+  │ 64:     </div>
+  │ 65:   </div>
+  │ 66:   <div class="card">
+  │ 67:     <div class="card-label">Uptime</div>
+  │ 68:     <div class="card-value">{{ c.uptime }}</div>
+  │ 69:     <div class="card-sub">{{ c.hostname }}</div>
+  │ 70:   </div>
+  │ 71: </div>
+  │ ```
+  │ Note the two-stage trigger pattern: the shell (index.html:25) uses `hx-trigger="load, every 2s"`
+  │ for the first fetch; every server-rendered fragment (line 1) uses only `hx-trigger="every 2s"`,
+  │ and because `hx-swap="outerHTML"` replaces the element with the identical re-armed div, the
+  │ self-poll continues.
+  │
+  │ ### `templates/disks.html`
+  │ ```html
+  │  1: <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="every 2s" hx-swap="outerHTML">
+  │  2:   <h2>Filesystems</h2>
+  │  3:   <div class="part-list">
+  │  4:     {% for p in partitions %}
+  │  5:     <div class="part">
+  │  6:       <div class="part-head">
+  │  7:         <span class="mono">{{ p.device }}</span>
+  │  8:         <span class="muted">{{ p.fstype }}</span>
+  │  9:         <span class="muted part-mounts" title="{{ p.mounts | join("\n") }}">{{ p.mounts_disp
+  │  }}</span>
+  │ 10:         <span class="part-usage">{{ p.used | humanize }} / {{ p.total | humanize }} ({{
+  │ p.pct | round(0) }}%)</span>
+  │ 11:       </div>
+  │ 12:       <div class="bar"><div class="bar-fill{% if p.pct > 90 %} hot{% elif p.pct > 75 %}
+  │ warm{% endif %}" style="width: {{ p.pct }}%"></div></div>
+  │ 13:     </div>
+  │ 14:     {% else %}
+  │ 15:     <div class="muted">no partitions found</div>
+  │ 16:     {% endfor %}
+  │ 17:   </div>
+  │ 18:   <h2>Device I/O</h2>
+  │ 19:   <div class="table-wrap">
+  │ 20:     <table class="table">
+  │ 21:       <colgroup>
+  │ 22:         <col style="width: 110px">
+  │ 23:         <col style="width: 100px">
+  │ 24:         <col style="width: 100px">
+  │ 25:         <col style="width: 100px">
+  │ 26:         <col style="width: 100px">
+  │ 27:         <col style="width: 110px">
+  │ 28:         <col style="width: 110px">
+  │ 29:       </colgroup>
+  │ 30:       <thead>
+  │ 31:         <tr><th>Device</th><th class="num">Read</th><th class="num">Write</th><th
+  │ class="num">Read rate</th><th class="num">Write rate</th><th class="num">Reads</th><th
+  │ class="num">Writes</th></tr>
+  │ 32:       </thead>
+  │ 33:       <tbody>
+  │ 34:       {% for d in per_disk %}
+  │ 35:         <tr>
+  │ 36:           <td class="mono cell-clip" title="{{ d.device }}">{{ d.device }}</td>
+  │ 37:           <td class="num">{{ d.read_bytes | humanize }}</td>
+  │ 38:           <td class="num">{{ d.write_bytes | humanize }}</td>
+  │ 39:           <td class="num">{{ d.read_rate | rate }}</td>
+  │ 40:           <td class="num">{{ d.write_rate | rate }}</td>
+  │ 41:           <td class="num">{{ d.reads }}</td>
+  │ 42:           <td class="num">{{ d.writes }}</td>
+  │ 43:         </tr>
+  │ 44:       {% else %}
+  │ 45:         <tr><td colspan="7" class="muted">no block devices</td></tr>
+  │ 46:       {% endfor %}
+  │ 47:       </tbody>
+  │ 48:     </table>
+  │ 49:   </div>
+  │ 50: </div>
+  │ ```
+  │
+  │ ### `templates/processes.html` (shows `hx-include` of the filter form + sortlinks)
+  │ ```html
+  │  1: <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="every 3s"
+  │  hx-swap="outerHTML" hx-include="#proc-controls">
+  │  2:   <div class="muted small">showing {{ procs | length }} of {{ total }} processes</div>
+  │  3:   <div class="table-wrap">
+  │  4:     <table class="table">
+  │  5:       <colgroup>
+  │  6:         <col style="width: 64px">
+  │  7:         <col>
+  │  8:         <col style="width: 100px">
+  │  9:         <col style="width: 72px">
+  │ 10:         <col style="width: 72px">
+  │ 11:         <col style="width: 92px">
+  │ 12:         <col style="width: 92px">
+  │ 13:         <col style="width: 92px">
+  │ 14:         <col style="width: 92px">
+  │ 15:       </colgroup>
+  │ 16:       <thead>
+  │ 17:         <tr>
+  │ 18:           {% for col, label in [("pid", "PID"), ("name", "Name"), ("user", "User"), ("cpu",
+  │ "CPU%"), ("mem_pct", "MEM%"), ("rss", "RSS"), ("gpu", "GPU"), ("io_read", "IO read"),
+  │ ("io_write", "IO write")] %}
+  │ 19:           <th class="{% if col in ('cpu','mem_pct','rss','gpu','io_read','io_write') %}num{%
+  │ endif %}">
+  │ 20:             <a href="#" class="sortlink{% if sort == col %} active{% endif %}" data-sort="{{
+  │ col }}" data-order="{% if sort == col and order == 'desc' %}asc{% else %}desc{% endif %}">{{
+  │ label }}{% if sort == col %} {{ "↓" if order == "desc" else "↑" }}{% endif %}</a>
+  │ 21:           </th>
+  │ 22:           {% endfor %}
+  │ 23:         </tr>
+  │ 24:       </thead>
+  │ 25:       <tbody>
+  │ 26:       {% for p in procs %}
+  │ 27:         <tr>
+  │ 28:           <td class="mono">{{ p.pid }}</td>
+  │ 29:           <td class="pname" title="{{ p.name }}">{{ p.name }}</td>
+  │ 30:           <td class="muted">{{ p.user }}</td>
+  │ 31:           <td class="num">{{ p.cpu | round(1) }}</td>
+  │ 32:           <td class="num">{{ p.mem_pct | round(1) }}</td>
+  │ 33:           <td class="num">{{ p.rss | humanize }}</td>
+  │ 34:           <td class="num">{% if p.gpu is not none %}{{ p.gpu }} MB{% else %}<span
+  │ class="muted">&mdash;</span>{% endif %}</td>
+  │ 35:           <td class="num">{{ p.io_read | rate }}</td>
+  │ 36:           <td class="num">{{ p.io_write | rate }}</td>
+  │ 37:         </tr>
+  │ 38:       {% else %}
+  │ 39:         <tr><td colspan="9" class="muted">no processes match</td></tr>
+  │ 40:       {% endfor %}
+  │ 41:       </tbody>
+  │ 42:     </table>
+  │ 43:   </div>
+  │ 44: </div>
+  │ ```
+  │
+  │ ### Other tabs (key lines)
+  │
+  │ `templates/services.html` (poll + lazy accordion rows + action buttons):
+  │ ```html
+  │  1: <div id="services" class="panel" hx-get="/api/services" hx-trigger="every 15s"
+  │  hx-swap="outerHTML" hx-include="#svc-filters">
+  │  ...
+  │ 30:         <tr class="svc-row" data-unit="{{ u.name }}">
+  │  ...
+  │ 32:           <td class="mono svc-name" role="button" tabindex="0" title="click for
+  │ details"><span class="svc-caret">▸</span>{{ u.name }}</td>
+  │  ...
+  │ 38:             <button class="btn" hx-post="/api/services/{{ u.name }}/action"
+  │ hx-vals='{"action":"start"}' hx-include="#svc-filters" hx-target="#services"
+  │ hx-swap="outerHTML">start</button>
+  │  ...
+  │ 40:             <button class="btn" hx-post="/api/services/{{ u.name }}/action"
+  │ hx-vals='{"action":"stop"}' hx-include="#svc-filters" hx-target="#services" hx-swap="outerHTML"
+  │ hx-confirm="Stop {{ u.name }}?">stop</button>
+  │  ...
+  │ 46:         <tr class="svc-detail-row" hidden data-unit="{{ u.name }}">
+  │ 47:           <td colspan="6"><div class="svc-detail"></div></td>
+  │ 48:         </tr>
+  │ ```
+  │
+  │ `templates/journal.html` (fragment is a batch of appended lines; the polling element lives in
+  │ index.html:73):
+  │ ```html
+  │  1: {% if error %}
+  │  2: <div class="jline j-error-once"><span class="muted">journalctl: {{ error }}</span></div>
+  │  3: {% endif %}
+  │  4: {% for e in entries %}
+  │  5: <div class="jline{% if e.prio <= 3 %} j-err{% elif e.prio == 4 %} j-warn{% endif %}"
+  │  data-cursor="{{ e.cursor }}">
+  │  6:   <span class="j-time">{{ e.stamp }}</span>
+  │  7:   <span class="j-ident">{{ e.ident }}</span>
+  │  8:   <span class="j-msg">{{ e.msg }}</span>
+  │  9: </div>
+  │ 10: {% endfor %}
+  │ ```
+  │
+  │ `templates/plugins.html` (shell for per-plugin skeletons; the tab itself only fetches once):
+  │ ```html
+  │ 1: <div id="plugins" class="panel">
+  │ 2:   {% for item in items %}
+  │ 3:   <div class="plugin-card">
+  │ 4:     <h3>{{ item.p.title }}</h3>
+  │ 5:     <p class="muted small">{{ item.p.description }}</p>
+  │ 6:     <div class="plugin-body">{{ item.body | safe }}</div>
+  │ 7:   </div>
+  │ 8:   {% else %}
+  │ 9:   <div class="muted">no plugins registered</div>
+  │ 10:  {% endfor %}
+  │ 11: </div>
+  │ ```
+  │ Each plugin's skeleton contains its own inner state div that polls (e.g.
+  │ `templates/plugins/sleep_skeleton.html` lines 1–5):
+  │ ```html
+  │ 1: <div class="sleep">
+  │ 2:   <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="every 5s"
+  │ hx-swap="innerHTML">
+  │ 3:     {% include "plugins/sleep_state.html" %}
+  │ 4:   </div>
+  │ 5: </div>
+  │ ```
+  │ Identical 5s pattern in `lact_skeleton.html:2`, `llamacpp_skeleton.html:2`,
+  │ `sessions_skeleton.html:2`.
+  │
+  │ ---
+  │
+  │ ## 5. All Existing JavaScript (`static/js/app.js`, full, 232 lines)
+  │
+  │ ```js
+  │   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.scales.y, extra);
+  │  55:     return o;
+  │  56:   }
+  │  57:
+  │  58:   function envelopeDs(name, color, s) {
+  │  59:     s = s || {};
+  │  60:     return [
+  │  61:       { label: name, data: s.max || [], borderColor: color, backgroundColor: color + "2e",
+  │  borderWidth: 1, pointRadius: 0, tension: 0, fill: false, order: 0 },
+  │  62:       { label: name + " min", band: true, data: s.min || [], borderColor: color,
+  │  backgroundColor: color, borderWidth: 1, pointRadius: 0, tension: 0, fill: false, order: 1 },
+  │  63:     ];
+  │  64:   }
+  │  65:
+  │  66:   const LEGEND = { display: true, labels: { boxWidth: 10, color: "#7d8a9c", filter: (item,
+  │  data) => !data.datasets[item.datasetIndex]?.band } };
+  │  67:
+  │  68:   function initCharts() {
+  │  69:     if (typeof Chart === "undefined") return;
+  │  70:     charts.cpu = new Chart(document.getElementById("chart-cpu"), {
+  │  71:       type: "line",
+  │  72:       data: {
+  │  73:         labels: [],
+  │  74:         datasets: [].concat(envelopeDs("CPU", "#4fc3f7"), envelopeDs("GPU", "#ba68c8")),
+  │  75:       },
+  │  76:       options: baseOpts({ max: 100 }),
+  │  77:     });
+  │  78:     charts.cpu.options.plugins.legend = LEGEND;
+  │  79:     charts.mem = new Chart(document.getElementById("chart-mem"), {
+  │  80:       type: "line",
+  │  81:       data: {
+  │  82:         labels: [],
+  │  83:         datasets: [].concat(envelopeDs("Memory", "#81c784"), envelopeDs("VRAM",
+  │  "#ffb74d")),
+  │  84:       },
+  │  85:       options: baseOpts({ max: 100 }),
+  │  86:     });
+  │  87:     charts.mem.options.plugins.legend = LEGEND;
+  │  88:     charts.io = new Chart(document.getElementById("chart-io"), {
+  │  89:       type: "line",
+  │  90:       data: {
+  │  91:         labels: [],
+  │  92:         datasets: [].concat(envelopeDs("read", "#e57373"), envelopeDs("write", "#fff176")),
+  │  93:       },
+  │  94:       options: baseOpts({
+  │  95:         ticks: { color: "#7d8a9c", callback: (v) => fmtBytes(v, 0) },
+  │  96:         beginAtZero: true,
+  │  97:       }),
+  │  98:     });
+  │  99:     charts.io.options.plugins.legend = LEGEND;
+  │ 100:   }
+  │ 101:
+  │ 102:   function updateCharts(hist) {
+  │ 103:     if (!hist || !hist.ts || !hist.ts.length) return;
+  │ 104:     const labels = hist.ts.map(fmtTime);
+  │ 105:     const series = hist.series || {};
+  │ 106:     const build = (chart, pairs) => {
+  │ 107:       chart.data.labels = labels;
+  │ 108:       chart.data.datasets = [];
+  │ 109:       pairs.forEach(([name, color, key], i) => {
+  │ 110:         const ds = envelopeDs(name, color, series[key]);
+  │ 111:         ds[0].fill = i * 2 + 1;
+  │ 112:         chart.data.datasets.push(...ds);
+  │ 113:       });
+  │ 114:       chart.update("none");
+  │ 115:     };
+  │ 116:     build(charts.cpu, [["CPU", "#4fc3f7", "cpu"], ["GPU", "#ba68c8", "gpu"]]);
+  │ 117:     build(charts.mem, [["Memory", "#81c784", "mem_pct"], ["VRAM", "#ffb74d", "vram_pct"]]);
+  │ 118:     build(charts.io, [["read", "#e57373", "io_read"], ["write", "#fff176", "io_write"]]);
+  │ 119:   }
+  │ 120:
+  │ 121:   function pollHistory() {
+  │ 122:     fetch("/api/history")
+  │ 123:       .then((r) => r.json())
+  │ 124:       .then(updateCharts)
+  │ 125:       .catch(() => {});
+  │ 126:   }
+  │ 127:
+  │ 128:   initCharts();
+  │ 129:   pollHistory();
+  │ 130:   setInterval(pollHistory, 2000);
+  │ 131:
+  │ 132:   // ---------- journal ----------
+  │ 133:   const journalLog = document.getElementById("journal-log");
+  │ 134:   const journalCursor = document.getElementById("journal-cursor");
+  │ 135:   const journalStatus = document.getElementById("journal-status");
+  │ 136:   const MAX_LINES = 500;
+  │ 137:
+  │ 138:   document.body.addEventListener("htmx:afterSwap", (e) => {
+  │ 139:     if (e.target.id !== "journal-log") return;
+  │ 140:     // surface one-shot errors in the status bar instead of the log
+  │ 141:     document.querySelectorAll("#journal-log .j-error-once").forEach((el) => {
+  │ 142:       journalStatus.textContent = el.textContent.trim();
+  │ 143:       el.remove();
+  │ 144:     });
+  │ 145:     // track cursor from the most recent line
+  │ 146:     const lines = journalLog.querySelectorAll(".jline");
+  │ 147:     const last = lines[lines.length - 1];
+  │ 148:     if (last && last.dataset.cursor) journalCursor.value = last.dataset.cursor;
+  │ 149:     // trim
+  │ 150:     const extra = lines.length - MAX_LINES;
+  │ 151:     if (extra > 0) {
+  │ 152:       for (let i = 0; i < extra; i++) lines[i].remove();
+  │ 153:     }
+  │ 154:     // auto-scroll if user is at the bottom (within 40px)
+  │ 155:     const wrap = document.getElementById("journal-logwrap");
+  │ 156:     const atBottom = wrap.scrollHeight - wrap.scrollTop - wrap.clientHeight < 40;
+  │ 157:     if (atBottom) wrap.scrollTop = wrap.scrollHeight;
+  │ 158:   });
+  │ 159:
+  │ 160:   // reset cursor when the filter form is submitted
+  │ 161:   const journalFilters = document.getElementById("journal-filters");
+  │ 162:   journalFilters.addEventListener("submit", () => {
+  │ 163:     journalCursor.value = "";
+  │ 164:     journalStatus.textContent = "";
+  │ 165:     journalLog.innerHTML = "";
+  │ 166:   });
+  │ 167:
+  │ 168:   // ---------- table sorting (processes, services) ----------
+  │ 169:   document.body.addEventListener("click", (e) => {
+  │ 170:     const link = e.target.closest(".sortlink");
+  │ 171:     if (!link) return;
+  │ 172:     e.preventDefault();
+  │ 173:     const formId = link.dataset.form || "proc-controls";
+  │ 174:     const form = document.getElementById(formId);
+  │ 175:     if (!form) return;
+  │ 176:     const sortSel = form.querySelector("select[name=sort]");
+  │ 177:     const orderSel = form.querySelector("select[name=order]");
+  │ 178:     if (sortSel) sortSel.value = link.dataset.sort;
+  │ 179:     if (orderSel) orderSel.value = link.dataset.order;
+  │ 180:     htmx.trigger(form, "submit");
+  │ 181:   });
+  │ 182:
+  │ 183:   // ---------- services accordion ----------
+  │ 184:   const openSvc = new Set();
+  │ 185:
+  │ 186:   function loadSvcDetail(unit, target) {
+  │ 187:     htmx.ajax("GET", "/api/services/" + encodeURIComponent(unit) + "/detail", { target });
+  │ 188:   }
+  │ 189:
+  │ 190:   function toggleSvcRow(row) {
+  │ 191:     const detailRow = row.nextElementSibling;
+  │ 192:     if (!detailRow || !detailRow.classList.contains("svc-detail-row")) return;
+  │ 193:     const unit = row.dataset.unit;
+  │ 194:     if (openSvc.has(unit)) {
+  │ 195:       openSvc.delete(unit);
+  │ 196:       row.classList.remove("open");
+  │ 197:       detailRow.hidden = true;
+  │ 198:     } else {
+  │ 199:       openSvc.add(unit);
+  │ 200:       row.classList.add("open");
+  │ 201:       detailRow.hidden = false;
+  │ 202:       loadSvcDetail(unit, detailRow.querySelector(".svc-detail"));
+  │ 203:     }
+  │ 204:   }
+  │ 205:
+  │ 206:   document.body.addEventListener("click", (e) => {
+  │ 207:     const row = e.target.closest("#services tr.svc-row");
+  │ 208:     if (!row || e.target.closest("button")) return;
+  │ 209:     toggleSvcRow(row);
+  │ 210:   });
+  │ 211:
+  │ 212:   document.body.addEventListener("keydown", (e) => {
+  │ 213:     const el = e.target.closest(".svc-name");
+  │ 214:     if (el && (e.key === "Enter" || e.key === " ")) {
+  │ 215:       e.preventDefault();
+  │ 216:       toggleSvcRow(el.closest("tr.svc-row"));
+  │ 217:     }
+  │ 218:   });
+  │ 219:
+  │ 220:   document.body.addEventListener("htmx:afterSwap", (e) => {
+  │ 221:     if (e.target.id !== "services" || !openSvc.size) return;
+  │ 222:     for (const row of e.target.querySelectorAll("tr.svc-row")) {
+  │ 223:       const unit = row.dataset.unit;
+  │ 224:       if (!openSvc.has(unit)) continue;
+  │ 225:       const detailRow = row.nextElementSibling;
+  │ 226:       if (!detailRow || !detailRow.classList.contains("svc-detail-row")) continue;
+  │ 227:       row.classList.add("open");
+  │ 228:       detailRow.hidden = false;
+  │ 229:       loadSvcDetail(unit, detailRow.querySelector(".svc-detail"));
+  │ 230:     }
+  │ 231:   });
+  │ 232: })();
+  │ ```
+  │
+  │ JS responsibilities in `app.js`, by section:
+  │ - **Tabs** (lines 4–19): click handlers, `.active`/`.hidden` toggling,
+  │ `localStorage["dash.tab"]` persistence + restore.
+  │ - **Charts** (lines 39–130): Chart.js init for the 3 canvases in the Overview section; **plain
+  │ `fetch` + `setInterval(pollHistory, 2000)`** polling `/api/history` (JSON, not htmx); envelope
+  │ (max/min band) datasets; legend filter hides the "min" band datasets.
+  │ - **Journal** (lines 132–166): `htmx:afterSwap` on `#journal-log` — moves `.j-error-once`
+  │ messages to `#journal-status`, tracks `data-cursor` from the last `.jline` into the hidden
+  │ `#journal-cursor` input, trims DOM to 500 lines, auto-scrolls if within 40px of bottom; filter
+  │ form submit clears cursor/status/log.
+  │ - **Table sorting** (lines 168–181): delegated click on `.sortlink` → writes
+  │ `data-sort`/`data-order` into the form's `select[name=sort]`/`select[name=order]` (form id from
+  │ `data-form`, default `proc-controls`) → `htmx.trigger(form, "submit")`.
+  │ - **Services accordion** (lines 183–231): delegated click/keydown on `#services tr.svc-row` →
+  │ `toggleSvcRow`, which shows/hides the sibling `.svc-detail-row` and lazy-fetches
+  │ `/api/services/<unit>/detail` via `htmx.ajax`; `htmx:afterSwap` on `#services` re-expands open
+  │ rows after the 15s poll re-renders the table (state kept in `openSvc` Set).
+  │
+  │ Everything is wrapped in an IIFE with `"use strict"`. It relies on the global `htmx` (loaded in
+  │ `<head>`) and `Chart` (vendor, loaded in `<head>`); `app.js` is loaded at the end of `<body>`
+  │ (index.html:98).
+  │
+  │ ---
+  │
+  │ ## 6. Polling Intervals per Tab/Section (summary table)
+  │
+  │ | Tab / element | Polling element (id) | Endpoint | Trigger | Swap | Interval |
+  │ |---|---|---|---|---|---|
+  │ | Overview cards | `#overview` (index.html:25 / overview.html:1) | `GET /api/overview` | `load,
+  │ every 2s` (shell) / `every 2s` (fragment) | `outerHTML` | **2s** |
+  │ | Overview charts (×3 canvases) | JS, not htmx (app.js:121–130) | `GET /api/history` (JSON) |
+  │ `setInterval` + initial call | n/a (Chart.js) | **2s** |
+  │ | Disks | `#disks` (index.html:34 / disks.html:1) | `GET /api/disks` | `load, every 2s` / `every
+  │ 2s` | `outerHTML` | **2s** |
+  │ | Processes | `#processes-body` (index.html:55 / processes.html:1) | `GET /api/processes` |
+  │ `load, every 3s` / `every 3s` | `outerHTML` (with `hx-include="#proc-controls"`) | **3s** |
+  │ | Journal | `#journal-log` (index.html:73) | `GET /api/journal` | `load, every 5s` | `beforeend`
+  │ (appends; `hx-include="#journal-filters, #journal-cursor"`) | **5s** |
+  │ | Services | `#services` (index.html:91 / services.html:1) | `GET /api/services` | `load, every
+  │ 15s` / `every 15s` | `outerHTML` (with `hx-include="#svc-filters"`) | **15s** |
+  │ | Service detail (lazy) | `.svc-detail` rows (services.html:47) | `GET
+  │ /api/services/{unit}/detail` | manual (`htmx.ajax` on expand) | `innerHTML` | on-demand |
+  │ | Plugins shell | `#plugins` (index.html:95) | `GET /api/plugins` | `load` only | `outerHTML` |
+  │ **once** |
+  │ | Plugin: llama.cpp | `#llama-state` (llamacpp_skeleton.html:2) | `GET
+  │ /api/plugins/llamacpp/state` | `every 5s` | `innerHTML` | **5s** |
+  │ | Plugin: sleep | `#sleep-state` (sleep_skeleton.html:2) | `GET /api/plugins/sleep/state` |
+  │ `every 5s` | `innerHTML` | **5s** |
+  │ | Plugin: LACT | `#lact-state` (lact_skeleton.html:2) | `GET /api/plugins/lact/state` | `every
+  │ 5s` | `innerHTML` | **5s** |
+  │ | Plugin: sessions | `#sessions-state` (sessions_skeleton.html:2) | `GET
+  │ /api/plugins/sessions/state` | `every 5s` | `innerHTML` | **5s** |
+  │
+  │ Non-polling htmx actions: service start/stop/restart/enable/disable buttons `POST
+  │ /api/services/{unit}/action` (services.html:38–43, `hx-target="#services"`, `hx-confirm` on
+  │ stop/restart); plugin POST actions (`/api/plugins/llamacpp/load|unload|rescan`,
+  │ `/api/plugins/sleep/toggle`, `/api/plugins/lact/set|reload`, `/api/plugins/sessions/terminate`)
+  │ all target `closest .plugin-body` with `innerHTML`.
+  │
+  │ ---
+  │
+  │ ## 7. Routers / Endpoints (tab-related, from `app/routers/` + `app/plugins/`)
+  │
+  │ Registered in `app/main.py:79–82` (six core routers + plugin-contributed routers):
+  │
+  │ | Method & path | Source file:line | Renders/does |
+  │ |---|---|---|
+  │ | `GET /` | `app/main.py:55–64, 83` | the `index.html` shell, rendered once |
+  │ | `GET /api/overview` | `app/routers/overview.py:19` | `overview.html` fragment |
+  │ | `GET /api/history` | `app/routers/overview.py:68` | JSON: window-averaged ring buffer (`{ts[],
+  │ series{key:{avg,min,max}}}`) |
+  │ | `GET /api/disks` | `app/routers/disks.py:16` | `disks.html` fragment |
+  │ | `GET /api/processes` | `app/routers/processes.py:14` | `processes.html` fragment (query: `q`,
+  │ `sort`, `order`) |
+  │ | `GET /api/journal` | `app/routers/journal.py:12` | `journal.html` batch (query: `level`,
+  │ `unit`, `search`, `hide_sudo`, `cursor`) |
+  │ | `GET /api/services` | `app/routers/services.py:100` | `services.html` fragment (query: `q`,
+  │ `sort`, `order`) |
+  │ | `GET /api/services/{unit}/detail` | `app/routers/services.py:115` | `service_detail.html`
+  │ fragment |
+  │ | `POST /api/services/{unit}/action` | `app/routers/services.py:144` | form field `action`
+  │ (start/stop/restart/enable/disable) |
+  │ | `GET /api/plugins` | `app/routers/plugins.py:10` | `plugins.html` with each plugin's
+  │ `skeleton()` (errors inlined per plugin) |
+  │ | `GET /api/plugins/llamacpp/state` | `app/plugins/llamacpp.py:192` (+ `POST /load`:198,
+  │ `/unload`:217, `/rescan`:236) | `llamacpp_state.html` |
+  │ | `GET /api/plugins/sleep/state` | `app/plugins/sleep.py:218` (+ `POST /toggle`:224) |
+  │ `sleep_state.html` |
+  │ | `GET /api/plugins/lact/state` | `app/plugins/lact.py:185` (+ `POST /set`:191, `/reload`:225) |
+  │ `lact_state.html` |
+  │ | `GET /api/plugins/sessions/state` | `app/plugins/sessions.py:125` (+ `POST /terminate`:131) |
+  │ `sessions_state.html` |
+  │
+  │ There are **no tab-related endpoints** (no `/api/tabs`, no server-side active-tab state). Tab
+  │ state is 100% client-side: DOM classes + `localStorage`.
+  │
+  │ ---
+  │
+  │ ## Key observations for anyone modifying the tab system
+  │
+  │ 1. **All tabs poll simultaneously from page load.** htmx does not pause `hx-trigger="every Ns"`
+  │ for `display:none` elements, so even while hidden, Disks (2s), Processes (3s), Journal (5s),
+  │ Services (15s), and the four plugin state divs (5s each) keep hitting the backend. Only the
+  │ Plugins tab's inner state divs start after the one-shot `/api/plugins` load resolves (since the
+  │ skeleton HTML — containing the `hx-trigger="every 5s"` divs — doesn't exist in the DOM until
+  │ then).
+  │ 2. **Self-poll pattern:** every fragment's root element re-declares its own
+  │ `hx-get`/`hx-trigger`/`hx-swap` with the same id, and uses `hx-swap="outerHTML"`, so each
+  │ response re-arms its own timer. The shell uses `hx-trigger="load, every 2s"` for the initial
+  │ fetch; fragments drop the `load` trigger.
+  │ 3. **Tab switching is pure vanilla JS** (no htmx on the buttons): class toggling (`.active` on
+  │ `button[data-tab]`, `.hidden` on `section#tab-<name>`) + `localStorage["dash.tab"]`
+  │ persistence/restore. No URL routing, no hash, no pushState.
+  │ 4. **The one non-htmx poll** is the Overview charts: `fetch("/api/history")` + `setInterval(...,
+  │ 2000)` in `app.js:121–130`, updating three Chart.js instances with `{avg,min,max}` envelope
+  │ series (min drawn as a band, hidden from the legend via the `band` flag +
+  │ `LEGEND.labels.filter`).
+  │ 5. **Form state survives polls** because polling divs use `hx-include` on the filter forms
+  │ (`#proc-controls`, `#svc-filters`, `#journal-filters`), and the forms live outside the swapped
+  │ panels — the swapped fragments never re-render the forms.
+  │ 6. **Journal is the only `beforeend`-swap tab** (append, not replace): cursor tracked via
+  │ `data-cursor` on `.jline` into a hidden input, DOM trimmed to 500 lines, and auto-scroll only
+  │ when the user is within 40px of the bottom (app.js:138–158).
+  │
+  │ tokens 1064 in 14649 out 27407 cached 0 written $0.0000 stop
+
diff --git a/static/js/app.js b/static/js/app.js
index b23d7f1..3b0e0b2 100644
--- a/static/js/app.js
+++ b/static/js/app.js
@@ -5,18 +5,60 @@
   const tabBtns = document.querySelectorAll(".tab-btn");
   const sections = document.querySelectorAll(".tab");
 
+  // per-tab poll interval (ms); htmx "every" timers cannot pause per
+  // element, so only the active tab polls: JS dispatches "dash-poll" on
+  // its section, where every polling element listens via
+  // hx-trigger="dash-poll from:#tab-<name>"
+  const TAB_INTERVALS = { overview: 2000, disks: 2000, processes: 3000, journal: 5000, services: 15000, plugins: 5000 };
+
+  let activeTab = null;
+  let pollTimer = null;
+  let histTimer = null;
+
+  function fireTabEvent(type, name) {
+    const sec = document.getElementById("tab-" + name);
+    if (sec) htmx.trigger(sec, type);
+  }
+
+  function setHistoryPolling(on) {
+    if (on && !histTimer) {
+      pollHistory();
+      histTimer = setInterval(pollHistory, 2000);
+    } else if (!on && histTimer) {
+      clearInterval(histTimer);
+      histTimer = null;
+    }
+  }
+
+  function stopPolling() {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+    setHistoryPolling(false);
+  }
+
+  function startTabPolling(name) {
+    stopPolling();
+    activeTab = name;
+    // "dash-activate" is the one-shot trigger (plugins list), "dash-poll"
+    // the recurring one; firing both refreshes the tab immediately
+    fireTabEvent("dash-activate", name);
+    fireTabEvent("dash-poll", name);
+    pollTimer = setInterval(() => fireTabEvent("dash-poll", name), TAB_INTERVALS[name] || 5000);
+    setHistoryPolling(name === "overview");
+  }
+
   function showTab(name) {
     tabBtns.forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
     sections.forEach((s) => s.classList.toggle("hidden", s.id !== "tab-" + name));
     try {
       localStorage.setItem("dash.tab", name);
     } catch (e) {}
+    startTabPolling(name);
   }
+
   tabBtns.forEach((b) => b.addEventListener("click", () => showTab(b.dataset.tab)));
-  try {
-    const saved = localStorage.getItem("dash.tab");
-    if (saved && document.getElementById("tab-" + saved)) showTab(saved);
-  } catch (e) {}
 
   // ---------- helpers ----------
   function fmtBytes(n, digits) {
@@ -126,8 +168,6 @@
   }
 
   initCharts();
-  pollHistory();
-  setInterval(pollHistory, 2000);
 
   // ---------- journal ----------
   const journalLog = document.getElementById("journal-log");
@@ -229,4 +269,19 @@
       loadSvcDetail(unit, detailRow.querySelector(".svc-detail"));
     }
   });
+
+  // ---------- startup ----------
+  // pause all polling while this browser tab is hidden, resume with a
+  // fresh fetch when it becomes visible again
+  document.addEventListener("visibilitychange", () => {
+    if (document.hidden) stopPolling();
+    else if (activeTab) startTabPolling(activeTab);
+  });
+
+  let initial = "overview";
+  try {
+    const saved = localStorage.getItem("dash.tab");
+    if (saved && document.getElementById("tab-" + saved)) initial = saved;
+  } catch (e) {}
+  showTab(initial);
 })();
diff --git a/templates/disks.html b/templates/disks.html
index 3bca3b1..c348b11 100644
--- a/templates/disks.html
+++ b/templates/disks.html
@@ -1,4 +1,4 @@
-<div id="disks" class="panel" hx-get="/api/disks" hx-trigger="every 2s" hx-swap="outerHTML">
+<div id="disks" class="panel" hx-get="/api/disks" hx-trigger="dash-poll from:#tab-disks" hx-swap="outerHTML">
   <h2>Filesystems</h2>
   <div class="part-list">
     {% for p in partitions %}
diff --git a/templates/index.html b/templates/index.html
index fcdb21b..5fa7f4e 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -22,7 +22,7 @@
 </header>
 <main>
   <section id="tab-overview" class="tab">
-    <div id="overview" class="panel" hx-get="/api/overview" hx-trigger="load, every 2s" hx-swap="outerHTML"></div>
+    <div id="overview" class="panel" hx-get="/api/overview" hx-trigger="dash-poll from:#tab-overview" hx-swap="outerHTML"></div>
     <div class="charts-grid">
       <div class="chart-card"><h3>CPU / GPU %</h3><canvas id="chart-cpu"></canvas></div>
       <div class="chart-card"><h3>Memory / VRAM %</h3><canvas id="chart-mem"></canvas></div>
@@ -31,7 +31,7 @@
   </section>
 
   <section id="tab-disks" class="tab hidden">
-    <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="load, every 2s" hx-swap="outerHTML"></div>
+    <div id="disks" class="panel" hx-get="/api/disks" hx-trigger="dash-poll from:#tab-disks" hx-swap="outerHTML"></div>
   </section>
 
   <section id="tab-processes" class="tab hidden">
@@ -52,7 +52,7 @@
       </select>
       <button type="submit">apply</button>
     </form>
-    <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="load, every 3s" hx-swap="outerHTML" hx-include="#proc-controls"></div>
+    <div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="dash-poll from:#tab-processes" hx-swap="outerHTML" hx-include="#proc-controls"></div>
   </section>
 
   <section id="tab-journal" class="tab hidden">
@@ -70,7 +70,7 @@
     </form>
     <div id="journal-logwrap">
       <input type="hidden" id="journal-cursor" name="cursor" value="">
-      <div id="journal-log" hx-get="/api/journal" hx-trigger="load, every 5s" hx-swap="beforeend" hx-include="#journal-filters, #journal-cursor"></div>
+      <div id="journal-log" hx-get="/api/journal" hx-trigger="dash-poll from:#tab-journal" hx-swap="beforeend" hx-include="#journal-filters, #journal-cursor"></div>
     </div>
   </section>
 
@@ -88,11 +88,11 @@
       </select>
       <button type="submit">filter</button>
     </form>
-    <div id="services" class="panel" hx-get="/api/services" hx-trigger="load, every 15s" hx-swap="outerHTML" hx-include="#svc-filters"></div>
+    <div id="services" class="panel" hx-get="/api/services" hx-trigger="dash-poll from:#tab-services" hx-swap="outerHTML" hx-include="#svc-filters"></div>
   </section>
 
   <section id="tab-plugins" class="tab hidden">
-    <div id="plugins" class="panel" hx-get="/api/plugins" hx-trigger="load" hx-swap="outerHTML"></div>
+    <div id="plugins" class="panel" hx-get="/api/plugins" hx-trigger="dash-activate from:#tab-plugins" hx-swap="outerHTML"></div>
   </section>
 </main>
 <script src="/static/js/app.js"></script>
diff --git a/templates/overview.html b/templates/overview.html
index 301d300..14ed1b1 100644
--- a/templates/overview.html
+++ b/templates/overview.html
@@ -1,4 +1,4 @@
-<div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="every 2s" hx-swap="outerHTML">
+<div id="overview" class="panel cards" hx-get="/api/overview" hx-trigger="dash-poll from:#tab-overview" hx-swap="outerHTML">
   {% macro bar(pct) %}{% if pct is not none %}<div class="bar"><div class="bar-fill{% if pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct }}%"></div></div>{% endif %}{% endmacro %}
   {% macro barrow(label, pct, cls) %}{% if pct is not none %}<div class="barrow"><span class="barrow-label">{{ label }}</span><div class="bar"><div class="bar-fill{% if cls %} {{ cls }}{% endif %}{% if pct > 85 %} hot{% elif pct > 65 %} warm{% endif %}" style="width: {{ pct }}%"></div></div></div>{% endif %}{% endmacro %}
   <div class="card">
diff --git a/templates/plugins/lact_skeleton.html b/templates/plugins/lact_skeleton.html
index 5d78e69..6e787c5 100644
--- a/templates/plugins/lact_skeleton.html
+++ b/templates/plugins/lact_skeleton.html
@@ -1,5 +1,5 @@
 <div class="lact">
-  <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="every 5s" hx-swap="innerHTML">
+  <div id="lact-state" hx-get="/api/plugins/lact/state" hx-trigger="dash-poll from:#tab-plugins" hx-swap="innerHTML">
     {% include "plugins/lact_state.html" %}
   </div>
   {% if gpus and not error %}
diff --git a/templates/plugins/llamacpp_skeleton.html b/templates/plugins/llamacpp_skeleton.html
index 140e0e8..e5045c1 100644
--- a/templates/plugins/llamacpp_skeleton.html
+++ b/templates/plugins/llamacpp_skeleton.html
@@ -1,5 +1,5 @@
 <div class="llama">
-  <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="every 5s" hx-swap="innerHTML">
+  <div id="llama-state" hx-get="/api/plugins/llamacpp/state" hx-trigger="dash-poll from:#tab-plugins" hx-swap="innerHTML">
     {% include "plugins/llamacpp_state.html" %}
   </div>
   {% if reachable %}
diff --git a/templates/plugins/sessions_skeleton.html b/templates/plugins/sessions_skeleton.html
index 3c93b43..f5a4f0a 100644
--- a/templates/plugins/sessions_skeleton.html
+++ b/templates/plugins/sessions_skeleton.html
@@ -1,5 +1,5 @@
 <div class="sessions">
-  <div id="sessions-state" hx-get="/api/plugins/sessions/state" hx-trigger="every 5s" hx-swap="innerHTML">
+  <div id="sessions-state" hx-get="/api/plugins/sessions/state" hx-trigger="dash-poll from:#tab-plugins" hx-swap="innerHTML">
     {% include "plugins/sessions_state.html" %}
   </div>
 </div>
diff --git a/templates/plugins/sleep_skeleton.html b/templates/plugins/sleep_skeleton.html
index 396d4f2..10c90a1 100644
--- a/templates/plugins/sleep_skeleton.html
+++ b/templates/plugins/sleep_skeleton.html
@@ -1,5 +1,5 @@
 <div class="sleep">
-  <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="every 5s" hx-swap="innerHTML">
+  <div id="sleep-state" hx-get="/api/plugins/sleep/state" hx-trigger="dash-poll from:#tab-plugins" hx-swap="innerHTML">
     {% include "plugins/sleep_state.html" %}
   </div>
 </div>
diff --git a/templates/processes.html b/templates/processes.html
index 2ca48b8..3c42758 100644
--- a/templates/processes.html
+++ b/templates/processes.html
@@ -1,4 +1,4 @@
-<div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="every 3s" hx-swap="outerHTML" hx-include="#proc-controls">
+<div id="processes-body" class="panel" hx-get="/api/processes" hx-trigger="dash-poll from:#tab-processes" hx-swap="outerHTML" hx-include="#proc-controls">
   <div class="muted small">showing {{ procs | length }} of {{ total }} processes</div>
   <div class="table-wrap">
     <table class="table">
diff --git a/templates/services.html b/templates/services.html
index 09f3b13..5ff1159 100644
--- a/templates/services.html
+++ b/templates/services.html
@@ -1,4 +1,4 @@
-<div id="services" class="panel" hx-get="/api/services" hx-trigger="every 15s" hx-swap="outerHTML" hx-include="#svc-filters">
+<div id="services" class="panel" hx-get="/api/services" hx-trigger="dash-poll from:#tab-services" hx-swap="outerHTML" hx-include="#svc-filters">
   {% if error %}<div class="alert">{{ error }}</div>{% endif %}
   <div class="muted small">system: {{ state }} &middot; {{ units | length }} units</div>
   <div class="table-wrap">