@andrian.yablonskyy/thub-coordinator 1.0.18 → 1.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrian.yablonskyy/thub-coordinator",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "TestHub Coordinator — job queue, resource registry, scheduler, heartbeat monitor, log/artifact store and web dashboard",
   "main": "src/server.js",
   "engines": {

package/public/css/thub.css

@@ -4,3 +4,27 @@
   white-space: pre-wrap;
   word-break: break-all;
 }
+
+/* Toast auto-close countdown (public/js/toasts.js): a thin bar along the
+   bottom that shrinks over the toast's delay; the toast closes when it
+   runs out. Hovering or focusing the toast pauses it. currentColor keeps
+   it readable on every text-bg-* variant. */
+.thub-toast-progress {
+  position: absolute;
+  inset: auto 0 0 0;
+  height: 3px;
+  background: currentColor;
+  opacity: 0.45;
+  transform-origin: left center;
+  animation: thub-toast-countdown var(--thub-toast-delay, 10s) linear forwards;
+}
+
+.toast:hover .thub-toast-progress,
+.toast:focus-within .thub-toast-progress {
+  animation-play-state: paused;
+}
+
+@keyframes thub-toast-countdown {
+  from { transform: scaleX(1); }
+  to { transform: scaleX(0); }
+}

package/public/js/toasts.js

@@ -22,12 +22,28 @@
   document.querySelectorAll('[data-thub-toast]').forEach((el) => {
     const type = el.dataset.thubToast in DELAY_MS ? el.dataset.thubToast : 'info',
       delay = el.dataset.sticky ? null : DELAY_MS[type],
-      toast = new bootstrap.Toast(el, { autohide: delay !== null, delay: delay ?? 0 });
+      // Our own countdown instead of Bootstrap's autohide: that one restarts
+      // the full delay after every hover, which a progress bar can't show.
+      toast = new bootstrap.Toast(el, { autohide: false });
     // "Self-destroying": gone from the page once hidden, not just invisible.
     el.addEventListener('hidden.bs.toast', () => {
       toast.dispose();
       el.remove();
     });
+
+    // The bar is the timer: a CSS animation over `delay` (paused while the
+    // toast is hovered or focused, see thub.css) — the toast closes when
+    // it ends. Added here, not in the markup, so without this script no
+    // bar suggests a close that would never happen.
+    if (delay !== null){
+      const bar = document.createElement('div');
+      bar.className = 'thub-toast-progress';
+      bar.setAttribute('aria-hidden', 'true');
+      bar.style.setProperty('--thub-toast-delay', `${delay}ms`);
+      bar.addEventListener('animationend', () => toast.hide(), { once: true });
+      el.classList.add('position-relative', 'overflow-hidden');
+      el.appendChild(bar);
+    }
     toast.show();
   });
 })();

package/public/js/update-watch.js

@@ -0,0 +1,54 @@
+/**
+ * @file        packages/coordinator/public/js/update-watch.js
+ * @description Dashboard: while a Coordinator self-update is pending, polls its status and reloads the page when done
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+(function (){
+  const marker = document.getElementById('coordinator-update-pending');
+  if (!marker){
+    return;
+  }
+  const currentVersion = marker.dataset.currentVersion,
+    POLL_MS = 3000;
+
+  // Reload once the Coordinator runs another version (the update is done),
+  // or no longer has one pending (it failed — the reloaded page says why).
+  // While it restarts, requests fail or hit the proxy's error page: keep
+  // polling. A reply that isn't our JSON (e.g. the login page, sessions
+  // having been reset by the restart) also means it's back — reload.
+  async function poll(){
+    let res;
+    try {
+      res = await fetch('/updates/status', { cache: 'no-store', credentials: 'same-origin', headers: { Accept: 'application/json' } });
+    }
+    catch {
+      return setTimeout(poll, POLL_MS); // down mid-restart
+    }
+    if (!res.ok){
+      return setTimeout(poll, POLL_MS); // e.g. 502 from the reverse proxy
+    }
+    let status;
+    try {
+      status = await res.json();
+    }
+    catch {
+      return location.reload();
+    }
+    if (status.coordinatorVersion !== currentVersion || !status.pending){
+      return location.reload();
+    }
+    setTimeout(poll, POLL_MS);
+  }
+
+  setTimeout(poll, POLL_MS);
+})();

package/scripts/install-systemd-unit.js

@@ -48,6 +48,7 @@ function renderUpdateUnits(user, paths){
     unitPath = (name) => path.join(__dirname, '..', 'systemd', name);
   return {
     [UPDATE_PATH_UNIT]: fs.readFileSync(unitPath(UPDATE_PATH_UNIT), 'utf8')
+      .replace(/^PathExists=.*$/m, `PathExists=${paths.updateRequestFile}`)
       .replace(/^PathModified=.*$/m, `PathModified=${paths.updateRequestFile}`),
     // npm is a `#!/usr/bin/env node` script, so this node goes first on PATH.
     [UPDATE_SERVICE_UNIT]: fs.readFileSync(unitPath(UPDATE_SERVICE_UNIT), 'utf8')

package/scripts/self-update-helper.js

@@ -15,9 +15,33 @@
 'use strict';
 
 const fs = require('node:fs'),
+  path = require('node:path'),
+  { execFileSync } = require('node:child_process'),
   { PACKAGES, isValidVersion, compareVersions, npmInstallGlobal } = require('@andrian.yablonskyy/thub-common'),
   { version: installedVersion } = require('../package.json');
 
+// Progress for the dashboard (services/updates.js reads it), next to the
+// request: {version, state, message, at} with state installing |
+// restarting | failed. Without it the dashboard can't tell a failed or
+// never-started update from one still running, and waits forever.
+let statusFile = null;
+function report(version, state, message = null){
+  if (!statusFile){
+    return;
+  }
+  try {
+    fs.writeFileSync(statusFile, JSON.stringify({ version, state, message, at: new Date().toISOString() }) + '\n', { mode: 0o644 });
+  }
+  catch (err){
+    console.error(`thub-coordinator-update: could not write ${statusFile}: ${err.message}`);
+  }
+}
+
+// The request only ever comes from a Coordinator older than `version`.
+function restartCoordinator(){
+  execFileSync('systemctl', ['restart', 'thub-coordinator.service'], { stdio: 'inherit' });
+}
+
 // argv: <request file> <user the Coordinator runs as>. The request file
 // is written by the (unprivileged) Coordinator, so only its `version` is
 // used, and only if it's a plain semver — the package is fixed.
@@ -27,6 +51,7 @@ function main(){
     console.error('usage: self-update-helper.js <request file> <user>');
     return 2;
   }
+  statusFile = path.join(path.dirname(requestFile), 'update-status.json');
 
   let request;
   try {
@@ -46,20 +71,41 @@ function main(){
   const target = request?.version;
   if (!isValidVersion(target)){
     console.error('thub-coordinator-update: ignoring request with an invalid version');
+    report(String(target), 'failed', 'The update request had an invalid version.');
     return 1;
   }
+  // Already installed on disk (e.g. a manual `npm i -g` whose restart never
+  // happened) while the running Coordinator is older — it asked, after all.
+  // Just restart it onto what's installed instead of leaving it waiting.
   if (compareVersions(installedVersion, target) >= 0){
-    console.log(`thub-coordinator-update: already on v${installedVersion} (requested v${target})`);
-    return 0;
+    console.log(`thub-coordinator-update: v${installedVersion} is already installed (requested v${target}) — restarting the Coordinator onto it`);
+    report(target, 'restarting');
+    try {
+      restartCoordinator();
+      return 0;
+    }
+    catch (err){
+      report(target, 'failed', `v${installedVersion} is installed, but restarting the Coordinator failed: ${err.message}`);
+      return 1;
+    }
   }
 
   console.log(`thub-coordinator-update: v${installedVersion} -> v${target} (requested by ${request.requestedBy || 'the dashboard'})`);
+  report(target, 'installing');
   // SUDO_USER makes the postinstall scripts target the Coordinator's user,
   // as a `sudo npm i -g` by that user would (install-target.js); the
   // postinstall then restarts thub-coordinator on the new version.
-  const status = npmInstallGlobal(PACKAGES.coordinator, target, { env: { ...process.env, SUDO_USER: user } });
+  let status;
+  try {
+    status = npmInstallGlobal(PACKAGES.coordinator, target, { env: { ...process.env, SUDO_USER: user } });
+  }
+  catch (err){
+    report(target, 'failed', `Could not run npm: ${err.message}`);
+    return 1;
+  }
   if (status !== 0){
     console.error(`thub-coordinator-update: npm i -g failed (exit ${status})`);
+    report(target, 'failed', `npm i -g failed (exit ${status}) — see: journalctl -u thub-coordinator-update`);
   }
   return status;
 }

package/src/db/migrations/016_add_list_prefs.sql

@@ -0,0 +1,5 @@
+-- Per-user list view preferences (README §10.1): page size and sort
+-- column/direction for each dashboard list, as JSON keyed by page —
+-- {"jobs": {"size": 25, "sort": "created", "dir": "desc"}, "resources": {...}}.
+-- NULL/missing keys fall back to each page's defaults (services/list-prefs.js).
+ALTER TABLE admin_users ADD COLUMN list_prefs TEXT;

package/src/services/admin-users.js

@@ -14,7 +14,8 @@
 'use strict';
 
 const crypto = require('node:crypto'),
-  { v4: uuid } = require('uuid');
+  { v4: uuid } = require('uuid'),
+  { normalize: normalizeListPrefs } = require('./list-prefs');
 
 function hashPassword(password){
   const salt = crypto.randomBytes(16).toString('hex'),
@@ -44,10 +45,21 @@ function toProfile(row){
     avatarPath: row.avatar_path,
     timezone: row.timezone,
     theme: row.theme,
-    sessionTimeoutMin: row.session_timeout_min
+    sessionTimeoutMin: row.session_timeout_min,
+    listPrefs: parseListPrefs(row.list_prefs)
   };
 }
 
+function parseListPrefs(json){
+  try {
+    const prefs = JSON.parse(json || '{}');
+    return prefs && typeof prefs === 'object' && !Array.isArray(prefs) ? prefs : {};
+  }
+  catch {
+    return {};
+  }
+}
+
 // §10: dashboard login uses its own admin/viewer account table with
 // session cookies — deliberately separate from the API bearer tokens.
 function createAdminUsersService(db){
@@ -157,6 +169,18 @@ function createAdminUsersService(db){
     return getById(id);
   }
 
+  // Remembers one list page's view (size/sort/dir, §10.1) for this user;
+  // stored normalized, so only valid values ever reach the profile.
+  function setListPrefs(id, list, prefs){
+    const row = db.prepare('SELECT list_prefs FROM admin_users WHERE id = ?').get(id);
+    if (!row){
+      throw Object.assign(new Error('Unknown user'), { status: 404 });
+    }
+    const all = { ...parseListPrefs(row.list_prefs), [list]: normalizeListPrefs(list, prefs) };
+    db.prepare('UPDATE admin_users SET list_prefs = ? WHERE id = ?').run(JSON.stringify(all), id);
+    return getById(id);
+  }
+
   return {
     getByUsername,
     getById,
@@ -166,6 +190,7 @@ function createAdminUsersService(db){
     changePassword,
     verify,
     updateProfile,
+    setListPrefs,
     SESSION_TIMEOUT_OPTIONS_MIN,
     THEMES
   };

package/src/services/jobs.js

@@ -13,7 +13,8 @@
 
 'use strict';
 
-const { validateJobSpec, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES } = require('@andrian.yablonskyy/thub-common');
+const { validateJobSpec, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES } = require('@andrian.yablonskyy/thub-common'),
+  { paginate } = require('./list-prefs');
 
 function rowToJob(row){
   if (!row){
@@ -79,6 +80,44 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
     return db.prepare(sql).all(...params).map(rowToJob);
   }
 
+  // Dashboard /jobs (§10): one sorted page plus the total, both in SQL so a
+  // long history never has to be loaded whole. `sort` is a list-prefs key.
+  const PAGE_SORT_SQL = {
+    id: 'jobs.id',
+    source: 'jobs.source',
+    user: 'json_extract(jobs.spec, \'$.user\')',
+    state: 'jobs.state',
+    resource: 'COALESCE(r.name, jobs.resource_name)',
+    created: 'jobs.created_at',
+    duration: 'jobs.duration_sec'
+  };
+
+  function page({ state, source, sort = 'created', dir = 'desc', size = 25, page: pageNo = 1 } = {}){
+    const where = [],
+      params = [];
+    if (state){
+      where.push('jobs.state = ?');
+      params.push(state);
+    }
+    if (source){
+      where.push('jobs.source = ?');
+      params.push(source);
+    }
+    const whereSql = where.length ? `WHERE ${where.join(' AND ')}` : '',
+      column = PAGE_SORT_SQL[sort] || PAGE_SORT_SQL.created,
+      order = dir === 'asc' ? 'ASC' : 'DESC',
+      total = db.prepare(`SELECT COUNT(*) AS n FROM jobs ${whereSql}`).get(...params).n,
+      pagination = paginate(total, size, pageNo),
+      // Empty values (no user, never ran, …) last either way; created_at
+      // breaks ties so paging is stable.
+      rows = db.prepare(
+        `SELECT jobs.* FROM jobs LEFT JOIN resources r ON r.id = jobs.resource_id ${whereSql}
+         ORDER BY ${column} IS NULL, ${column} ${order}, jobs.created_at DESC
+         LIMIT ? OFFSET ?`
+      ).all(...params, pagination.limit, pagination.offset);
+    return { rows: rows.map(rowToJob), pagination };
+  }
+
   function countQueuedForAgent(agentId){
     return db
       .prepare('SELECT COUNT(*) AS n FROM jobs WHERE agent_id = ? AND state IN (\'QUEUED\',\'ASSIGNED\')')
@@ -363,6 +402,15 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
     return active.length;
   }
 
+  // How many jobs Reset queue / Clean history would touch — shown in their
+  // confirmation modals on /jobs.
+  function countActiveAndFinished(){
+    const count = (states) => db
+      .prepare(`SELECT COUNT(*) AS n FROM jobs WHERE state IN (${[...states].map(() => '?').join(',')})`)
+      .get(...states).n;
+    return { active: count(ACTIVE_JOB_STATES), finished: count(TERMINAL_JOB_STATES) };
+  }
+
   // Admin: "clean the queue" — permanently delete finished jobs (and their
   // logs/artifacts, on disk and in the DB), for when the history itself,
   // not just active work, needs clearing out. Unlike the nightly retention
@@ -406,6 +454,7 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
   return {
     get,
     list,
+    page,
     create,
     setState,
     cancel,
@@ -420,6 +469,7 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
     checkAssignAcks,
     reconcileOnStartup,
     resetQueue,
+    countActiveAndFinished,
     cleanHistory
   };
 }

package/src/services/list-prefs.js

@@ -0,0 +1,92 @@
+/**
+ * @file        packages/coordinator/src/services/list-prefs.js
+ * @description Per-user list view preferences (page size, sort column/direction) for the dashboard's
+ *              Jobs and Resources pages (README §10.1), plus the pagination math they share
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+// 'all' shows every record on one page.
+const PAGE_SIZES = [10, 25, 50, 100, 'all'],
+  DEFAULT_PAGE_SIZE = 25,
+  DIRS = ['asc', 'desc'],
+
+  // Sortable columns per page, and each page's default order. The keys are
+  // what the URL (?sort=) and the stored profile carry; the pages map them
+  // to actual columns (jobs.page's SQL, the resources route's comparators).
+  LISTS = {
+    jobs: {
+      sorts: ['id', 'source', 'user', 'state', 'resource', 'created', 'duration'],
+      defaults: { size: DEFAULT_PAGE_SIZE, sort: 'created', dir: 'desc' }
+    },
+    resources: {
+      sorts: ['name', 'type', 'version', 'status', 'heartbeat'],
+      defaults: { size: DEFAULT_PAGE_SIZE, sort: 'name', dir: 'asc' }
+    }
+  };
+
+function parseSize(value){
+  if (value === 'all'){
+    return 'all';
+  }
+  const n = Number(value);
+  return PAGE_SIZES.includes(n) ? n : undefined;
+}
+
+// A complete, valid {size, sort, dir} for `list`: each field from `prefs`
+// when valid there, else that page's default.
+function normalize(list, prefs = {}){
+  const def = LISTS[list];
+  if (!def){
+    throw Object.assign(new Error(`Unknown list "${list}"`), { status: 400 });
+  }
+  return {
+    size: parseSize(prefs.size) ?? def.defaults.size,
+    sort: def.sorts.includes(prefs.sort) ? prefs.sort : def.defaults.sort,
+    dir: DIRS.includes(prefs.dir) ? prefs.dir : def.defaults.dir
+  };
+}
+
+// What a request asks for: the stored prefs, overridden by whichever of
+// ?size / ?sort / ?dir the URL carries (invalid values are ignored).
+function fromQuery(list, query, stored){
+  const base = normalize(list, stored),
+    wanted = { ...base };
+  if (query.size !== undefined && parseSize(query.size) !== undefined){
+    wanted.size = parseSize(query.size);
+  }
+  if (LISTS[list].sorts.includes(query.sort)){
+    wanted.sort = query.sort;
+  }
+  if (DIRS.includes(query.dir)){
+    wanted.dir = query.dir;
+  }
+  return { prefs: wanted, changed: ['size', 'sort', 'dir'].some((k) => wanted[k] !== base[k]) };
+}
+
+// Page window for `total` records: `page` is 1-based and clamped into range.
+function paginate(total, size, page){
+  const limit = size === 'all' ? Math.max(total, 1) : size,
+    pages = Math.max(1, Math.ceil(total / limit)),
+    current = Math.min(Math.max(1, Number.parseInt(page, 10) || 1), pages),
+    offset = (current - 1) * limit;
+  return {
+    page: current,
+    pages,
+    total,
+    offset,
+    limit,
+    from: total ? offset + 1 : 0,
+    to: Math.min(offset + limit, total)
+  };
+}
+
+module.exports = { PAGE_SIZES, DEFAULT_PAGE_SIZE, LISTS, normalize, fromQuery, paginate };

package/src/services/updates.js

@@ -15,21 +15,82 @@
 
 const fs = require('node:fs'),
   path = require('node:path'),
-  { PACKAGES, fetchLatestVersion, defaultRegistry, isNewer } = require('@andrian.yablonskyy/thub-common'),
+  { PACKAGES, fetchLatestVersion, defaultRegistry, isNewer, compareVersions } = require('@andrian.yablonskyy/thub-common'),
   { version: coordinatorVersion } = require('../../package.json');
 
 // Installed by scripts/install-systemd-unit.js; runs the actual `npm i -g`
 // as root when the dashboard writes an update request (README §10.2).
-const UPDATE_PATH_UNIT = '/etc/systemd/system/thub-coordinator-update.path';
+const UPDATE_PATH_UNIT = '/etc/systemd/system/thub-coordinator-update.path',
+  // No sign of the root helper by then: the request wasn't picked up.
+  PICKUP_TIMEOUT_MS = 60_000,
+  // Longer than thub-coordinator-update.service's TimeoutStartSec (15 min).
+  INSTALL_TIMEOUT_MS = 20 * 60_000;
 
 // Latest published versions, refreshed every `updates.checkIntervalMin`
 // and on demand from the dashboard. Kept in memory only — a restart just
 // checks again.
-function createUpdatesService({ config }){
+// `pathUnit`, `fetchLatest` and `now` are overridable for tests only.
+function createUpdatesService({ config, pathUnit = UPDATE_PATH_UNIT, fetchLatest = fetchLatestVersion, now = Date.now }){
   const registry = config.updates.registry || defaultRegistry(),
-    state = { latest: {}, checkedAt: null, error: null, coordinatorPending: null };
+    state = { latest: {}, checkedAt: null, error: null, coordinatorPending: null, coordinatorRequestedAt: null, coordinatorUpdateError: null },
+    requestFile = path.join(config.dataDir, 'update-request.json'),
+    // Written by the root helper (scripts/self-update-helper.js).
+    statusFile = path.join(config.dataDir, 'update-status.json');
   let inFlight = null;
 
+  function readHelperStatus(){
+    try {
+      return JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+    }
+    catch {
+      return null;
+    }
+  }
+
+  function failPending(message){
+    state.coordinatorUpdateError = { version: state.coordinatorPending, message, at: new Date().toISOString() };
+    state.coordinatorPending = null;
+    state.coordinatorRequestedAt = null;
+    console.error(`Coordinator self-update failed: ${message}`);
+  }
+
+  // A pending update ends with this process being restarted onto the new
+  // version. Anything else — the helper reporting failure, never picking
+  // the request up, or taking far too long — must end the wait too, or the
+  // dashboard shows "Updating…" forever.
+  function refreshPending(){
+    if (!state.coordinatorPending){
+      return;
+    }
+    const requestedAt = Date.parse(state.coordinatorRequestedAt),
+      helper = readHelperStatus(),
+      fresh = helper && Date.parse(helper.at) >= requestedAt - 1000;
+    if (fresh && helper.state === 'failed'){
+      failPending(helper.message || 'The update helper reported a failure — see: journalctl -u thub-coordinator-update');
+    }
+    else if (!fresh && now() - requestedAt > PICKUP_TIMEOUT_MS){
+      failPending(
+        fs.existsSync(requestFile)
+          ? `The update request wasn't picked up within ${PICKUP_TIMEOUT_MS / 1000} s — is the watcher running? ` +
+            'sudo systemctl enable --now thub-coordinator-update.path'
+          : 'The update helper started but never reported progress — see: journalctl -u thub-coordinator-update'
+      );
+    }
+    else if (fresh && now() - Date.parse(helper.at) > INSTALL_TIMEOUT_MS){
+      failPending(`The update has been "${helper.state}" for over ${INSTALL_TIMEOUT_MS / 60_000} min — see: journalctl -u thub-coordinator-update`);
+    }
+  }
+
+  // On startup: a helper status for this version (or older) means the
+  // update that restarted us is done — clear it.
+  function settleHelperStatus(){
+    const helper = readHelperStatus();
+    if (helper && helper.state !== 'failed' && compareVersions(coordinatorVersion, String(helper.version)) >= 0){
+      fs.rmSync(statusFile, { force: true });
+      console.log(`Coordinator self-update to v${helper.version} completed`);
+    }
+  }
+
   async function checkNow(){
     // Concurrent callers (timer + a dashboard click) share one check.
     inFlight = inFlight || (async () => {
@@ -37,7 +98,7 @@ function createUpdatesService({ config }){
         errors = [];
       await Promise.all(Object.entries(PACKAGES).map(async ([app, pkg]) => {
         try {
-          latest[app] = await fetchLatestVersion(pkg, { registry });
+          latest[app] = await fetchLatest(pkg, { registry });
         }
         catch (err){
           errors.push(err.message);
@@ -55,6 +116,7 @@ function createUpdatesService({ config }){
   }
 
   function status(){
+    refreshPending();
     return {
       ...state,
       coordinatorVersion,
@@ -70,17 +132,19 @@ function createUpdatesService({ config }){
     if (!target){
       throw Object.assign(new Error(`Already on the latest version (v${coordinatorVersion}).`), { status: 409 });
     }
-    if (!fs.existsSync(UPDATE_PATH_UNIT)){
+    if (!fs.existsSync(pathUnit)){
       throw Object.assign(
-        new Error(`Self-update isn't installed on this host (${UPDATE_PATH_UNIT}) — update by hand: thub-admin self-update`),
+        new Error(`Self-update isn't installed on this host (${pathUnit}) — update by hand: thub-admin self-update`),
         { status: 501 }
       );
     }
-    fs.writeFileSync(
-      path.join(config.dataDir, 'update-request.json'),
-      JSON.stringify({ version: target, requestedBy, requestedAt: new Date().toISOString() }) + '\n'
-    );
+    const requestedAt = new Date(now()).toISOString();
+    // A previous attempt's result mustn't be mistaken for this one's.
+    fs.rmSync(statusFile, { force: true });
+    fs.writeFileSync(requestFile, JSON.stringify({ version: target, requestedBy, requestedAt }) + '\n');
     state.coordinatorPending = target;
+    state.coordinatorRequestedAt = requestedAt;
+    state.coordinatorUpdateError = null;
     return target;
   }
 
@@ -97,6 +161,7 @@ function createUpdatesService({ config }){
   }
 
   function start(){
+    settleHelperStatus();
     const minutes = Number(config.updates.checkIntervalMin);
     if (!(minutes > 0)){
       return;

package/src/web/routes.js

@@ -20,12 +20,25 @@ const fs = require('node:fs'),
   multer = require('multer'),
   { requireAdminSession, requireAdminRole } = require('../auth'),
   { attachJobStream } = require('../api/sse'),
-  { RESOURCE_STATES, JOB_STATES, ACTIVE_JOB_STATES, isNewer } = require('@andrian.yablonskyy/thub-common');
+  { RESOURCE_STATES, JOB_STATES, ACTIVE_JOB_STATES, isNewer, compareVersions } = require('@andrian.yablonskyy/thub-common'),
+  listPrefs = require('../services/list-prefs');
+
+// Resources page sort keys (list-prefs.js) -> comparators. Empty values
+// (never heartbeated, no version reported) sort last in both directions.
+const RESOURCE_SORT_VALUE = {
+    name: (r) => r.name,
+    type: (r) => r.type,
+    version: (r) => r.client_version,
+    status: (r) => r.status,
+    heartbeat: (r) => r.last_heartbeat_at
+  },
+  compareResourceValues = (sort, a, b) =>
+    sort === 'version' ? compareVersions(a, b) : String(a).localeCompare(String(b), undefined, { numeric: true }),
 
-// §10.1: avatar uploads are small, single images — a hard size cap and an
-// allow-list of image mimetypes, same spirit as the join-key/token checks
-// elsewhere (reject outright rather than trying to sanitize).
-const AVATAR_MAX_BYTES = 2 * 1024 * 1024,
+  // §10.1: avatar uploads are small, single images — a hard size cap and an
+  // allow-list of image mimetypes, same spirit as the join-key/token checks
+  // elsewhere (reject outright rather than trying to sanitize).
+  AVATAR_MAX_BYTES = 2 * 1024 * 1024,
   AVATAR_EXT_BY_MIMETYPE = {
     'image/png': 'png',
     'image/jpeg': 'jpg',
@@ -55,6 +68,30 @@ function createWebRouter({ services, config }){
     return typeof target === 'string' && /^\/(?![\/\\])/.test(target) ? target : fallback;
   }
 
+  // A list page's view (§10.1): the user's stored size/sort/dir, overridden
+  // by ?size/?sort/?dir — and a change is saved straight to their profile,
+  // so it's what they get next time on any device. ?page isn't saved.
+  function listView(req, res, list, extraQuery = {}){
+    const user = req.session.user,
+      { prefs, changed } = listPrefs.fromQuery(list, req.query, user.listPrefs?.[list]);
+    if (changed){
+      req.session.user = services.adminUsers.setListPrefs(user.id, list, prefs);
+      res.locals.user = req.session.user;
+    }
+    const base = { ...extraQuery, size: prefs.size, sort: prefs.sort, dir: prefs.dir },
+      // Link to this list with some params changed; changing size or sort
+      // restarts at page 1. Empty params are dropped.
+      urlFor = (changes = {}) => {
+        const q = { ...base, ...changes };
+        if (('size' in changes || 'sort' in changes) && !('page' in changes)){
+          delete q.page;
+        }
+        const qs = new URLSearchParams(Object.entries(q).filter(([, v]) => v !== undefined && v !== null && v !== '')).toString();
+        return `${req.baseUrl}${req.path}${qs ? `?${qs}` : ''}`;
+      };
+    return { prefs, urlFor, pageSizes: listPrefs.PAGE_SIZES };
+  }
+
   // The job each resource is on (if any), for the resource card's Cancel.
   function withActiveJobs(resources){
     return resources.map((r) => ({ ...r, activeJob: services.jobs.activeForResource(r.id) }));
@@ -66,6 +103,18 @@ function createWebRouter({ services, config }){
     res.locals.messages = req.session?.flash || [];
     // Latest published versions (README §10.2) — navbar, Agents, Resources.
     res.locals.updates = services.updates.status();
+    // A failed Coordinator self-update: shown to each admin once, as an
+    // error toast (never auto-closes) — on a page view, not the polling
+    // endpoint or a POST whose redirect would drop it.
+    const updateError = res.locals.updates.coordinatorUpdateError;
+    if (updateError && user?.role === 'admin' && req.method === 'GET' && req.path !== '/updates/status' &&
+      req.session.seenUpdateError !== updateError.at){
+      req.session.seenUpdateError = updateError.at;
+      res.locals.messages = [
+        ...res.locals.messages,
+        { type: 'danger', text: `Coordinator update to v${updateError.version} failed: ${updateError.message}` }
+      ];
+    }
     res.locals.isNewer = isNewer;
     res.locals.currentPath = req.originalUrl;
     if (req.session){
@@ -231,12 +280,26 @@ function createWebRouter({ services, config }){
   });
 
   router.get('/resources', (req, res) => {
-    const groupsById = Object.fromEntries(services.groups.list().map((g) => [g.id, g]));
+    const groupsById = Object.fromEntries(services.groups.list().map((g) => [g.id, g])),
+      view = listView(req, res, 'resources'),
+      { sort, dir, size } = view.prefs,
+      value = RESOURCE_SORT_VALUE[sort],
+      sorted = services.registry.list().sort((a, b) => {
+        const va = value(a),
+          vb = value(b);
+        if (va == null || vb == null){
+          return (va == null) - (vb == null);
+        }
+        return (dir === 'asc' ? 1 : -1) * compareResourceValues(sort, va, vb) || a.name.localeCompare(b.name);
+      }),
+      pagination = listPrefs.paginate(sorted.length, size, req.query.page),
+      pageUrl = (changes) => view.urlFor({ page: pagination.page, ...changes });
     res.render('resources/list', {
       title: 'Resources',
       active: 'resources',
-      resources: withActiveJobs(services.registry.list()),
-      groupsById
+      resources: withActiveJobs(sorted.slice(pagination.offset, pagination.offset + pagination.limit)),
+      groupsById,
+      list: { ...view, pagination, pageUrl }
     });
   });
 
@@ -376,9 +439,21 @@ function createWebRouter({ services, config }){
   router.post('/updates/coordinator', requireAdminRole, updateAction(async (req) => {
     const version = services.updates.requestCoordinatorUpdate(req.session.user.username);
     console.log(`Coordinator self-update to v${version} requested by ${req.session.user.username}`);
-    return `Updating the Coordinator to v${version} — the dashboard restarts in a minute or two; reload the page then.`;
+    return `Updating the Coordinator to v${version} — this page reloads by itself once it's back up.`;
   }));
 
+  // Polled by public/js/update-watch.js while a Coordinator update is
+  // pending: a new `coordinatorVersion` (the restart happened) or a cleared
+  // `pending` (it failed) tells the page to reload.
+  router.get('/updates/status', (req, res) => {
+    const s = services.updates.status();
+    res.set('Cache-Control', 'no-store').json({
+      coordinatorVersion: s.coordinatorVersion,
+      pending: s.coordinatorPending,
+      error: s.coordinatorUpdateError
+    });
+  });
+
   router.post('/resources/update-all', requireAdminRole, updateAction(async () => {
     const version = await services.updates.targetVersion('client'),
       n = services.registry.requestUpdateAll(version);
@@ -413,22 +488,25 @@ function createWebRouter({ services, config }){
 
   router.get('/jobs', (req, res) => {
     const filters = { state: req.query.state || undefined, source: req.query.source || undefined },
-      jobs = services.jobs.list({ ...filters, limit: 200 }).map((j) => ({
+      view = listView(req, res, 'jobs', filters),
+      { rows, pagination } = services.jobs.page({ ...filters, ...view.prefs, page: req.query.page }),
+      jobs = rows.map((j) => ({
         ...j,
         resource: j.resource_id ? services.registry.get(j.resource_id) : null,
         active: ACTIVE_JOB_STATES.has(j.state)
-      }));
+      })),
+      pageUrl = (changes) => view.urlFor({ page: pagination.page, ...changes });
     res.render('jobs/list', {
       title: 'Jobs',
       active: 'jobs',
       jobs,
       filters,
-      // Keeps the list's filters across a row's Cancel.
-      filterQuery: (() => {
-        const q = new URLSearchParams(Object.entries(filters).filter(([, v]) => v)).toString();
-        return q ? `?${q}` : '';
-      })(),
-      canManage: req.session.user.role === 'admin'
+      list: { ...view, pagination, pageUrl },
+      // A row's Cancel comes back to this exact view (filters, sort, page).
+      returnTo: pageUrl(),
+      canManage: req.session.user.role === 'admin',
+      // For the Reset queue / Clean history confirmation modals.
+      jobCounts: req.session.user.role === 'admin' ? services.jobs.countActiveAndFinished() : null
     });
   });
 

package/systemd/thub-coordinator-update.path

@@ -1,11 +1,14 @@
 [Unit]
 Description=TestHub Coordinator self-update request watcher
 
-# PathModified= is rewritten by scripts/install-systemd-unit.js to the
-# update-request.json in the Coordinator's dataDir. The dashboard's
+# PathExists=/PathModified= are rewritten by scripts/install-systemd-unit.js
+# to the update-request.json in the Coordinator's dataDir. The dashboard's
 # "Update app" button writes it; this starts thub-coordinator-update.service
-# (as root) to install the requested version.
+# (as root) to install the requested version. PathExists= also catches a
+# request written while this watch wasn't active (e.g. mid-reinstall) — the
+# helper deletes the file, so it doesn't re-trigger.
 [Path]
+PathExists=/var/lib/thub/.thub/update-request.json
 PathModified=/var/lib/thub/.thub/update-request.json
 Unit=thub-coordinator-update.service
 

package/test/list-prefs.test.js

@@ -0,0 +1,89 @@
+/**
+ * @file        packages/coordinator/test/list-prefs.test.js
+ * @description Tests: list view preferences (page size/sort), their storage in the user profile, and paged job queries
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+const test = require('node:test'),
+  assert = require('node:assert/strict'),
+  { EventEmitter } = require('node:events'),
+  { openDb } = require('../src/db'),
+  { createAdminUsersService } = require('../src/services/admin-users'),
+  { createEventsService } = require('../src/services/events'),
+  { createRegistryService } = require('../src/services/registry'),
+  { createAgentsService } = require('../src/services/agents'),
+  { createJobsService } = require('../src/services/jobs'),
+  { normalize, fromQuery, paginate } = require('../src/services/list-prefs');
+
+test('normalize fills defaults and drops invalid values', () => {
+  assert.deepEqual(normalize('jobs'), { size: 25, sort: 'created', dir: 'desc' });
+  assert.deepEqual(normalize('resources', { size: '100', sort: 'status', dir: 'desc' }), { size: 100, sort: 'status', dir: 'desc' });
+  assert.deepEqual(normalize('resources', { size: 7, sort: 'labels', dir: 'up' }), { size: 25, sort: 'name', dir: 'asc' });
+  assert.equal(normalize('jobs', { size: 'all' }).size, 'all');
+  assert.throws(() => normalize('nope'), /Unknown list/);
+});
+
+test('fromQuery overrides stored prefs and reports whether anything changed', () => {
+  const stored = { size: 50, sort: 'state', dir: 'asc' };
+  assert.deepEqual(fromQuery('jobs', {}, stored), { prefs: stored, changed: false });
+  assert.deepEqual(fromQuery('jobs', { size: '10', page: '3' }, stored), { prefs: { ...stored, size: 10 }, changed: true });
+  assert.equal(fromQuery('jobs', { sort: 'bogus', size: '11' }, stored).changed, false); // invalid: ignored
+});
+
+test('paginate clamps the page and computes the window', () => {
+  assert.deepEqual(paginate(112, 25, '3'), { page: 3, pages: 5, total: 112, offset: 50, limit: 25, from: 51, to: 75 });
+  assert.equal(paginate(112, 25, '99').page, 5);
+  assert.equal(paginate(112, 25, 'x').page, 1);
+  assert.deepEqual(paginate(112, 'all', 1), { page: 1, pages: 1, total: 112, offset: 0, limit: 112, from: 1, to: 112 });
+  assert.deepEqual(paginate(0, 10, 1), { page: 1, pages: 1, total: 0, offset: 0, limit: 10, from: 0, to: 0 });
+});
+
+test('list prefs are stored per page in the user profile', () => {
+  const users = createAdminUsersService(openDb(':memory:')),
+    { id } = users.create({ username: 'alice', password: 'pw', role: 'admin' });
+  assert.deepEqual(users.getById(id).listPrefs, {});
+
+  users.setListPrefs(id, 'jobs', { size: 100, sort: 'duration', dir: 'asc' });
+  const profile = users.setListPrefs(id, 'resources', { size: 'all', sort: 'nonsense' });
+  assert.deepEqual(profile.listPrefs, {
+    jobs: { size: 100, sort: 'duration', dir: 'asc' },
+    resources: { size: 'all', sort: 'name', dir: 'asc' }
+  });
+});
+
+test('jobs.page sorts and pages in SQL, with empty values last', () => {
+  const db = openDb(':memory:'),
+    bus = new EventEmitter(),
+    events = createEventsService(db),
+    registry = createRegistryService(db, { bus, events }),
+    { agent } = createAgentsService(db, { events }).create({ name: 'ci', kind: 'ci' }),
+    config = { scheduler: { maxQueuedPerAgent: 100 }, jobs: { defaultTimeoutSec: 60, maxTimeoutSec: 60 } },
+    jobs = createJobsService(db, { bus, events, registry, artifacts: {}, config });
+  registry.registerAuto({ clientId: 'c', name: 'lab', type: 'sw', labels: [] });
+
+  const ids = ['carol', 'alice', null, 'bob'].map((user) =>
+      jobs.create({
+        agentId: agent.id,
+        source: 'cli',
+        spec: { target: { type: 'sw' }, firmware: { url: 'https://x/a' }, tests: { url: 'https://x/t' }, ...(user ? { user } : {}) }
+      }).id),
+
+    byUser = (dir) => jobs.page({ sort: 'user', dir, size: 'all' }).rows.map((j) => j.spec.user ?? null);
+  assert.deepEqual(byUser('asc'), ['alice', 'bob', 'carol', null]);
+  assert.deepEqual(byUser('desc'), ['carol', 'bob', 'alice', null]);
+
+  const second = jobs.page({ sort: 'id', dir: 'asc', size: 2, page: 2 });
+  assert.deepEqual(second.rows.map((j) => j.id), ids.slice(2));
+  assert.equal(second.pagination.total, 4);
+  assert.equal(second.pagination.pages, 2);
+  assert.equal(jobs.page({ state: 'PASSED' }).pagination.total, 0);
+});

package/test/updates.test.js

@@ -0,0 +1,106 @@
+/**
+ * @file        packages/coordinator/test/updates.test.js
+ * @description Tests: Coordinator self-update request lifecycle — the dashboard never waits forever on a stuck update
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+const test = require('node:test'),
+  assert = require('node:assert/strict'),
+  fs = require('node:fs'),
+  os = require('node:os'),
+  path = require('node:path'),
+  { createUpdatesService } = require('../src/services/updates'),
+  { version: installed } = require('../package.json');
+
+const NEWER = installed.replace(/\d+$/, (n) => String(Number(n) + 1));
+
+async function setup(){
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thub-updates-')),
+    pathUnit = path.join(dataDir, 'fake.path'),
+    clock = { t: Date.parse('2026-09-28T12:00:00Z') };
+  fs.writeFileSync(pathUnit, '');
+  const updates = createUpdatesService({
+    config: { dataDir, updates: {} },
+    pathUnit,
+    fetchLatest: async () => NEWER,
+    now: () => clock.t
+  });
+  await updates.checkNow();
+  const helperSays = (state, message) => fs.writeFileSync(
+    path.join(dataDir, 'update-status.json'),
+    JSON.stringify({ version: NEWER, state, message, at: new Date(clock.t).toISOString() })
+  );
+  return { updates, dataDir, clock, helperSays };
+}
+
+test('a request is written for the root helper and shows as pending', async () => {
+  const { updates, dataDir } = await setup();
+  assert.equal(updates.requestCoordinatorUpdate('alice'), NEWER);
+  assert.equal(JSON.parse(fs.readFileSync(path.join(dataDir, 'update-request.json'), 'utf8')).version, NEWER);
+  assert.equal(updates.status().coordinatorPending, NEWER);
+});
+
+test('a request nobody picks up stops pending after the pickup timeout, with the reason', async () => {
+  const { updates, clock } = await setup();
+  updates.requestCoordinatorUpdate('alice');
+  clock.t += 30_000;
+  assert.equal(updates.status().coordinatorPending, NEWER); // still within the timeout
+  clock.t += 31_000;
+  const s = updates.status();
+  assert.equal(s.coordinatorPending, null);
+  assert.match(s.coordinatorUpdateError.message, /wasn't picked up.*thub-coordinator-update\.path/);
+});
+
+test('a helper failure ends the wait at once with its message', async () => {
+  const { updates, clock, helperSays } = await setup();
+  updates.requestCoordinatorUpdate('alice');
+  clock.t += 2000;
+  helperSays('installing');
+  assert.equal(updates.status().coordinatorPending, NEWER);
+  helperSays('failed', 'npm i -g failed (exit 1)');
+  const s = updates.status();
+  assert.equal(s.coordinatorPending, null);
+  assert.deepEqual([s.coordinatorUpdateError.version, s.coordinatorUpdateError.message], [NEWER, 'npm i -g failed (exit 1)']);
+});
+
+test('an install that runs far too long times out; a normal one keeps pending', async () => {
+  const { updates, clock, helperSays } = await setup();
+  updates.requestCoordinatorUpdate('alice');
+  helperSays('installing');
+  clock.t += 5 * 60_000;
+  assert.equal(updates.status().coordinatorPending, NEWER);
+  clock.t += 16 * 60_000;
+  assert.match(updates.status().coordinatorUpdateError.message, /"installing" for over 20 min/);
+});
+
+test('a stale failure from an earlier attempt is not mistaken for the new one', async () => {
+  const { updates, clock, helperSays } = await setup();
+  helperSays('failed', 'old failure');
+  clock.t += 60_000;
+  updates.requestCoordinatorUpdate('alice'); // removes the old status
+  assert.equal(updates.status().coordinatorPending, NEWER);
+  assert.equal(updates.status().coordinatorUpdateError, null);
+});
+
+test('on startup, a finished update\'s status is cleared; a failure is kept for the dashboard', async () => {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'thub-updates-')),
+    statusFile = path.join(dataDir, 'update-status.json'),
+    make = () => createUpdatesService({ config: { dataDir, updates: {} }, fetchLatest: async () => installed });
+
+  fs.writeFileSync(statusFile, JSON.stringify({ version: installed, state: 'installing', at: new Date().toISOString() }));
+  make().start();
+  assert.equal(fs.existsSync(statusFile), false);
+
+  fs.writeFileSync(statusFile, JSON.stringify({ version: NEWER, state: 'failed', at: new Date().toISOString() }));
+  make().start();
+  assert.equal(fs.existsSync(statusFile), true);
+});

package/views/jobs/list.pug

@@ -1,15 +1,15 @@
 extends ../layout
 include ../mixins/status-badge
+include ../mixins/list-controls
+include ../mixins/confirm-modal
 
 block content
   .d-flex.justify-content-between.align-items-center.mb-3
     h1.h4.mb-0 Jobs
     if canManage
       .btn-group
-        form(method="post" action="/jobs/reset-queue" onsubmit="return confirm('Cancel every queued/assigned/preparing/running job? This stops in-flight work.')")
-          button.btn.btn-sm.btn-outline-warning(type="submit") Reset queue
-        form.ms-1(method="post" action="/jobs/clean-history" onsubmit="return confirm('Permanently delete all finished jobs and their logs/artifacts? This cannot be undone.')")
-          button.btn.btn-sm.btn-outline-danger(type="submit") Clean history
+        button.btn.btn-sm.btn-outline-warning(type="button" data-bs-toggle="modal" data-bs-target="#reset-queue-modal") Reset queue
+        button.btn.btn-sm.btn-outline-danger.ms-1(type="button" data-bs-toggle="modal" data-bs-target="#clean-history-modal") Clean history
 
   form.row.g-2.mb-3(method="get")
     .col-auto
@@ -22,17 +22,21 @@ block content
         option(value="") any source
         option(value="ci" selected=filters.source === 'ci') ci
         option(value="cli" selected=filters.source === 'cli') cli
+    .col-auto.ms-auto
+      +pageSizePicker(list)
+
+  +listToolbar(list, 'jobs')
 
   table.table.table-hover.align-middle
     thead
       tr
-        th Job
-        th Source
-        th User
-        th State
-        th Resource
-        th Created
-        th Duration
+        +sortHeader(list, 'id', 'Job')
+        +sortHeader(list, 'source', 'Source')
+        +sortHeader(list, 'user', 'User')
+        +sortHeader(list, 'state', 'State')
+        +sortHeader(list, 'resource', 'Resource')
+        +sortHeader(list, 'created', 'Created', 'desc')
+        +sortHeader(list, 'duration', 'Duration', 'desc')
         if canManage
           th
     tbody
@@ -54,6 +58,52 @@ block content
                   data-confirm=`Cancel job ${j.id}?`
                   onsubmit="return confirm(this.dataset.confirm)"
                 )
-                  input(type="hidden" name="returnTo" value=`/jobs${filterQuery}`)
+                  input(type="hidden" name="returnTo" value=returnTo)
                   button.btn.btn-sm.btn-outline-danger(type="submit" aria-label="Cancel" title="Cancel this job")
                     i.bi.bi-x-circle
+
+  if canManage
+    +confirmModal({
+      id: 'reset-queue-modal',
+      tone: 'warning',
+      icon: 'bi-exclamation-triangle-fill',
+      title: 'Reset the job queue?',
+      action: '/jobs/reset-queue',
+      confirmLabel: 'Cancel all active jobs',
+      confirmIcon: 'bi-x-octagon',
+      disabled: !jobCounts.active
+    })
+      if jobCounts.active
+        p
+          | This cancels
+          |
+          strong= `${jobCounts.active} active job${jobCounts.active === 1 ? '' : 's'}`
+          |  — everything queued, assigned, preparing or running. Running jobs are stopped on their Clients, and all of them end as
+          |
+          code CANCELED
+          | .
+        p.small.text-body-secondary.mb-0 Finished jobs, logs and artifacts are not touched.
+      else
+        p.mb-0 There are no active jobs — nothing to cancel.
+
+    +confirmModal({
+      id: 'clean-history-modal',
+      tone: 'danger',
+      icon: 'bi-trash3-fill',
+      title: 'Clean job history?',
+      action: '/jobs/clean-history',
+      confirmLabel: 'Delete finished jobs',
+      confirmIcon: 'bi-trash3',
+      disabled: !jobCounts.finished
+    })
+      if jobCounts.finished
+        p
+          | This permanently deletes
+          |
+          strong= `${jobCounts.finished} finished job${jobCounts.finished === 1 ? '' : 's'}`
+          |  together with their logs and artifacts (database rows and files on disk).
+        p.mb-0
+          strong This cannot be undone.
+          |  Active jobs are not touched.
+      else
+        p.mb-0 There are no finished jobs — nothing to delete.

package/views/layout.pug

@@ -52,7 +52,14 @@ html(lang="en" data-bs-theme=(user && user.theme) || "auto")
             if user && user.role === 'admin' && updates.coordinatorUpdate
               li.nav-item.d-flex.align-items-center.me-3
                 if updates.coordinatorPending
-                  button.btn.btn-sm.btn-warning(type="button" disabled)
+                  //- public/js/update-watch.js polls /updates/status and
+                  //- reloads the page once the new version is up (or the
+                  //- update failed, to show why).
+                  button.btn.btn-sm.btn-warning#coordinator-update-pending(
+                    type="button"
+                    disabled
+                    data-current-version=coordinatorVersion
+                  )
                     span.spinner-border.spinner-border-sm.me-1(aria-hidden="true")
                     = `Updating app to ${updates.coordinatorPending}…`
                 else
@@ -104,12 +111,16 @@ html(lang="en" data-bs-theme=(user && user.theme) || "auto")
                   )
                     i.bi.bi-box-arrow-right
     //- Flash messages as toasts (public/js/toasts.js): errors stay until
-    //- closed, warnings close after 30 s, info/success after 10 s. Rendered
+    //- closed, warnings close after 30 s, info/success after 10 s, with a
+    //- countdown bar along the bottom (paused on hover). Rendered
     //- visible (.show), so they're readable even if the script fails.
     if messages && messages.length
       .toast-container.position-fixed.end-0.p-3(style="top: 3.5rem; z-index: 1090;")
         each m in messages
-          - const type = ['danger', 'warning', 'info', 'success'].includes(m.type) ? m.type : 'info'
+          //- Error-level aliases map to danger (never auto-closes); anything
+          //- else unknown is shown as info.
+          - const alias = { error: 'danger', critical: 'danger', fatal: 'danger' }[m.type] || m.type
+          - const type = ['danger', 'warning', 'info', 'success'].includes(alias) ? alias : 'info'
           - const icon = { danger: 'x-octagon-fill', warning: 'exclamation-triangle-fill', info: 'info-circle-fill', success: 'check-circle-fill' }[type]
           .toast.show.border-0(
             class=`text-bg-${type}`
@@ -136,4 +147,6 @@ html(lang="en" data-bs-theme=(user && user.theme) || "auto")
     script(src="/js/tooltips.js")
     script(src="/js/toasts.js")
     script(src="/js/copy-to-clipboard.js")
+    if user && user.role === 'admin' && updates.coordinatorPending
+      script(src="/js/update-watch.js")
     block scripts

package/views/mixins/confirm-modal.pug

@@ -0,0 +1,26 @@
+//- A confirmation modal for a destructive admin action that POSTs to
+//- `opts.action`: opened by a button with data-bs-toggle="modal"
+//- data-bs-target="#<opts.id>" (no JS needed). The block is the body text.
+//- opts: id, title, action, confirmLabel, and optional tone (Bootstrap
+//- color, default danger), icon / confirmIcon (bootstrap-icons classes),
+//- disabled (nothing to do — the confirm button is disabled).
+mixin confirmModal(opts)
+  - const tone = opts.tone || 'danger'
+  .modal.fade(id=opts.id tabindex="-1" aria-labelledby=`${opts.id}-title` aria-hidden="true")
+    .modal-dialog.modal-dialog-centered
+      .modal-content
+        .modal-header(class=`text-bg-${tone}`)
+          h5.modal-title(id=`${opts.id}-title`)
+            if opts.icon
+              i.bi.me-2(class=opts.icon)
+            = opts.title
+          button.btn-close(type="button" data-bs-dismiss="modal" aria-label="Close")
+        .modal-body
+          block
+        .modal-footer
+          button.btn.btn-secondary(type="button" data-bs-dismiss="modal") Keep
+          form(method="post" action=opts.action)
+            button.btn(type="submit" class=`btn-${tone}` disabled=opts.disabled)
+              if opts.confirmIcon
+                i.bi.me-1(class=opts.confirmIcon)
+              = opts.confirmLabel

package/views/mixins/list-controls.pug

@@ -0,0 +1,61 @@
+//- Pagination and sorting for the dashboard's list pages (Jobs, Resources;
+//- README §10.1). `list` comes from routes.js listView(): prefs {size, sort,
+//- dir}, pagination {page, pages, total, from, to}, pageSizes, urlFor(changes)
+//- (link with params changed; size/sort changes restart at page 1).
+
+//- Records-per-page picker — placed on the right of the page's filter row.
+//- Navigates on change (no `name`), so it never rides along with a filter
+//- form it sits in.
+mixin pageSizePicker(list)
+  .d-flex.align-items-center.gap-2
+    label.small.text-body-secondary.mb-0.text-nowrap(for="list-page-size") Show
+    select.form-select.form-select-sm.w-auto#list-page-size(
+      aria-label="Records per page"
+      onchange="location.href = this.value"
+    )
+      each s in list.pageSizes
+        option(value=list.urlFor({ size: s }) selected=list.prefs.size === s)= s === 'all' ? 'All' : s
+
+//- Shown above the table: "Showing 26–50 of 312 jobs" and the page links.
+mixin listToolbar(list, noun)
+  - const p = list.pagination
+  .d-flex.flex-wrap.align-items-center.justify-content-between.gap-2.mb-2
+    span.small.text-body-secondary
+      if p.total
+        | Showing #{p.from}–#{p.to} of #{p.total} #{noun}
+      else
+        | No #{noun}
+    if p.pages > 1
+      +pager(list)
+
+//- First / previous / a window of pages around the current one / next / last.
+mixin pager(list)
+  - const p = list.pagination
+  - const from = Math.max(1, Math.min(p.page - 2, p.pages - 4))
+  - const to = Math.min(p.pages, from + 4)
+  nav(aria-label="Pages")
+    ul.pagination.pagination-sm.mb-0
+      li.page-item(class=p.page === 1 ? 'disabled' : null)
+        a.page-link(href=list.pageUrl({ page: 1 }) aria-label="First page") «
+      li.page-item(class=p.page === 1 ? 'disabled' : null)
+        a.page-link(href=list.pageUrl({ page: p.page - 1 }) aria-label="Previous page") ‹
+      - for (let n = from; n <= to; n++)
+        li.page-item(class=n === p.page ? 'active' : null aria-current=n === p.page ? 'page' : null)
+          a.page-link(href=list.pageUrl({ page: n }))= n
+      li.page-item(class=p.page === p.pages ? 'disabled' : null)
+        a.page-link(href=list.pageUrl({ page: p.page + 1 }) aria-label="Next page") ›
+      li.page-item(class=p.page === p.pages ? 'disabled' : null)
+        a.page-link(href=list.pageUrl({ page: p.pages }) aria-label="Last page") »
+
+//- A sortable column header: click to sort by it, again to flip direction.
+//- `firstDir` is the direction a column starts in (desc for times/durations).
+mixin sortHeader(list, key, label, firstDir)
+  - const active = list.prefs.sort === key
+  - const nextDir = active ? (list.prefs.dir === 'asc' ? 'desc' : 'asc') : (firstDir || 'asc')
+  th(aria-sort=active ? (list.prefs.dir === 'asc' ? 'ascending' : 'descending') : null)
+    a.link-body-emphasis.text-decoration-none.text-nowrap(href=list.urlFor({ sort: key, dir: nextDir }))
+      = label
+      if active
+        i.bi.ms-1(class=list.prefs.dir === 'asc' ? 'bi-caret-up-fill' : 'bi-caret-down-fill')
+      else
+        i.bi.bi-arrow-down-up.ms-1.text-body-tertiary.small

package/views/resources/list.pug

@@ -2,26 +2,31 @@ extends ../layout
 include ../mixins/status-badge
 include ../mixins/resource
 include ../mixins/updates
+include ../mixins/list-controls
 
 block content
   h1.h4.mb-3 Resources
   p.text-body-secondary.small.
     Resources register themselves — start a Client with the shared join key and it appears here. Click a resource for its details, including IP addresses.
 
-  .mb-3
+  .d-flex.flex-wrap.align-items-center.gap-2.mb-3
     +updatesToolbar('client', 'clients', '/resources')
+    .ms-auto
+      +pageSizePicker(list)
+
+  +listToolbar(list, 'resources')
 
   table.table.table-hover.align-middle
     thead
       tr
-        th Name
-        th Type
-        th Version
-        th Status
+        +sortHeader(list, 'name', 'Name')
+        +sortHeader(list, 'type', 'Type')
+        +sortHeader(list, 'version', 'Version', 'desc')
+        +sortHeader(list, 'status', 'Status')
         th Labels
         th Groups
         th Busy source / reason
-        th Last heartbeat
+        +sortHeader(list, 'heartbeat', 'Last heartbeat', 'desc')
         if user.role === 'admin'
           th Actions
     tbody
@@ -44,10 +49,10 @@ block content
           td= fmtDate(r.last_heartbeat_at, 'never')
           if user.role === 'admin'
             td
-              +resourceActions(r, '/resources')
+              +resourceActions(r, list.pageUrl())
 
   each r in resources
-    +resourceCard(r, groupsById, '/resources')
+    +resourceCard(r, groupsById, list.pageUrl())
 
   if user && user.role === 'admin'
     +removeResourceModal()