feat(webui): migrate Dashboard + Tasks to feature modules

Two more pages on the feature-module contract (specs produced + adversarially
verified by workflow):
- features/dashboard/index.js: landing page; mount() folds in the data-reload
  that used to be a navigate() special-case (now deleted from spa.js, so it
  fires exactly once). No controller class — uses the eager dashboard.js globals.
- features/tasks/index.js: re-inits the system-loader tasksManager singleton;
  unmount() clears the 30s auto-refresh interval + open log streams WITHOUT
  stopping the shared SSE bus or nulling the singleton.

Verifier fixes applied: deleted the duplicate dashboard reload in navigate();
dropped a dead detachDashboardLive() call; fixed an invalid try{}while(false)
in the tasks unmount.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Signed-off-by: librelad <librelad@digitalangels.vip>

containers/libreportal/frontend/features/dashboard/index.js

@@ -0,0 +1,42 @@
+// features/dashboard/index.js — the landing Dashboard as a feature module.
+//
+// dashboard.js exposes bare global functions (loadInstalledApps,
+// loadDashboardData live in dashboard.js / data-loader.js, both eager core
+// scripts) — there is no controller class to lazy-load, so scripts is empty.
+// system-loader's 'dashboard' component already ran initializeData()/
+// loadSystemInfo()/setupEventListeners() once at boot; mount() only does the
+// per-navigation refresh (mirrors the old handleDashboard + the navigate()
+// data-reload special-case, which has been removed from spa.js so the reload
+// now fires exactly once here).
+LP.features.register({
+  id: 'dashboard',
+  routes: ['/', '/dashboard'],
+
+  async mount(ctx) {
+    const html = await ctx.loadFragment('/html/dashboard-content.html');
+    ctx.setContent(html, 'Dashboard');
+
+    // Render the installed-apps icon grid (handleDashboard's only post-render call).
+    if (typeof loadInstalledApps === 'function') loadInstalledApps();
+
+    // Repaint the stat cards / disk donut + (re)wire the 1 Hz live SSE. The
+    // 100 ms cushion lets the freshly-injected DOM settle (loadSystemInfo also
+    // guards on element presence). ctx.sub() cancels it if we navigate away
+    // before it fires.
+    const reloadTimer = setTimeout(() => {
+      if (typeof loadDashboardData === 'function') loadDashboardData();
+    }, 100);
+    ctx.sub(() => clearTimeout(reloadTimer));
+  },
+
+  async unmount() {
+    // Nothing this view owns is destroyable from here: the dashboard has no
+    // handler-newed controller and no system-loader singleton to tear down.
+    // The pending reload timer is cancelled via the ctx.sub() above (ctx.teardown).
+    // The 1 Hz LiveSystem SSE sub (attachDashboardLive) self-releases on its
+    // next sample once the dashboard DOM is gone, and the 1 s update countdown
+    // is a module-private interval with no exported stopper (pre-existing; it
+    // self-clears on the next dashboard mount). Both are noted for the Phase 5
+    // dashboard cleanup; neither is reachable here.
+  },
+});

containers/libreportal/frontend/features/tasks/index.js

@@ -0,0 +1,45 @@
+// features/tasks/index.js — the Tasks page as a feature module.
+//
+// window.tasksManager is a system-loader singleton (its "task-system" component
+// loads all task scripts, starts the shared SSE bus, then news TasksManager).
+// So mount() does NOT new it or load scripts — it renders the fragment and
+// re-inits the view, exactly like the old handleTasks(). unmount() releases
+// only this view's per-mount leaks (the 30s auto-refresh interval + open log
+// streams); it must never stop the shared taskEventBus or null the singleton.
+LP.features.register({
+  id: 'tasks',
+  routes: ['/tasks', '/tasks*'],
+
+  async mount(ctx) {
+    const html = await ctx.loadFragment('/html/tasks-content.html');
+    ctx.setContent(html, 'Tasks');
+
+    if (window.tasksManager) {
+      await window.tasksManager.init();
+    } else {
+      // Don't throw — matches handleTasks: the page still renders, task
+      // functionality is just limited until the task-system component is ready.
+      console.warn('TasksManager not available yet, task functionality will be limited');
+    }
+  },
+
+  async unmount() {
+    const tm = window.tasksManager;
+    // The one per-view leak init() opens: the 30s auto-refresh interval stored
+    // on the singleton. Each init() recreates it, so clearing here is idempotent.
+    if (tm && tm.refreshInterval) {
+      clearInterval(tm.refreshInterval);
+      tm.refreshInterval = null;
+    }
+    // Stop any open per-task log streams this view started (each removes its own
+    // SSE listeners + map entry). Snapshot keys first — stopLogStreaming mutates
+    // the map. Does NOT touch the shared bus.
+    if (tm && tm.activeLogStreams && typeof tm.stopLogStreaming === 'function') {
+      for (const id of Array.from(tm.activeLogStreams.keys())) {
+        try { tm.stopLogStreaming(id); } catch (_) {}
+      }
+    }
+    // DO NOT: stop window.taskEventBus (shared SSE singleton), remove the
+    // singleton's once-bound task listeners, or null window.tasksManager.
+  },
+});

containers/libreportal/frontend/index.html

@@ -111,7 +111,9 @@
   <script src="/kernel/lifecycle.js"></script>
   <!-- Feature modules self-register here (eager, tiny). Their heavy controllers
        are still lazy-loaded by the module's mount(). -->
+  <script src="/features/dashboard/index.js"></script>
   <script src="/features/backup/index.js"></script>
+  <script src="/features/tasks/index.js"></script>
   <!--
     Page-specific controllers are loaded on demand by spa.js / config-manager.js
     when the user navigates to the relevant route. Keeping them out of the

containers/libreportal/frontend/js/spa.js

@@ -231,16 +231,9 @@ class LibrePortalSPAClean {
       }
     }
 
-    // Force data reload when navigating to dashboard, even if same route
-    if (path === '/dashboard' || path === '/') {
-      // console.log('🔄 Dashboard navigation detected, forcing data reload');
-      // Trigger dashboard data reload after a short delay to ensure DOM is ready
-      setTimeout(() => {
-        if (typeof loadDashboardData === 'function') {
-          loadDashboardData();
-        }
-      }, 100);
-    }
+    // (The dashboard data-reload that used to live here is now folded into the
+    // dashboard feature module's mount(), so it fires exactly once per
+    // navigation. See features/dashboard/index.js.)
 
     this.isLoading = true;
     //console.log('🧭 Navigating to:', path);