@andrian.yablonskyy/thub-coordinator 1.0.17 → 1.0.19

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) }));
@@ -231,12 +268,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 }
     });
   });
 
@@ -284,6 +335,26 @@ function createWebRouter({ services, config }){
     res.redirect(returnTo(req, '/resources'));
   });
 
+  router.post('/resources/:id/remove', requireAdminRole, (req, res) => {
+    try {
+      const { resource: r, pending, stoppedJob, canceledJobs } = services.jobs.removeResource(req.params.id, {
+        by: req.session.user.username,
+        stopJob: req.body.stopJob === '1'
+      });
+      flash(
+        req,
+        'warning',
+        pending
+          ? `Stopped job ${stoppedJob} on ${r.name}; ${r.name} is removed as soon as its Client confirms the job ended.`
+          : `Removed ${r.name}.` + (canceledJobs.length ? ` Canceled job(s) queued for it: ${canceledJobs.join(', ')}.` : '')
+      );
+    }
+    catch (err){
+      flash(req, 'danger', err.message);
+    }
+    res.redirect(returnTo(req, '/resources'));
+  });
+
   router.post('/resources/:id/rotate-token', requireAdminRole, (req, res) => {
     const { generateToken, hashToken } = require('../services/tokens');
     const token = generateToken('res');
@@ -393,16 +464,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
-      }));
+        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,
-      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
     });
   });
 
@@ -440,9 +520,16 @@ function createWebRouter({ services, config }){
     });
   });
 
+  // From the job page or a row on /jobs (returnTo says which).
   router.post('/jobs/:id/cancel', requireAdminRole, (req, res) => {
-    services.jobs.cancel(req.params.id, { isAdmin: true });
-    res.redirect(`/jobs/${req.params.id}`);
+    try {
+      services.jobs.cancel(req.params.id, { isAdmin: true });
+      flash(req, 'warning', `Canceled job ${req.params.id}.`);
+    }
+    catch (err){
+      flash(req, 'danger', err.message);
+    }
+    res.redirect(returnTo(req, `/jobs/${req.params.id}`));
   });
 
   // Plain, one-shot fetch — used by the log viewer for a job that's

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/scheduler.test.js

@@ -157,6 +157,34 @@ test('job ids are split by source: A-##### for ci, M-##### for cli', () => {
   assert.equal(Number(ciJob2.id.slice(2)), Number(ciJob.id.slice(2)) + 1);
 });
 
+test('default priority follows the job source; an explicit one is kept', () => {
+  const { agents, registry, jobs } = buildTestServices(),
+    { agent } = agents.create({ name: 'ci', kind: 'ci' });
+  registerResource(registry, { name: 'lab-sw-01', type: 'sw' });
+
+  assert.equal(jobs.create({ agentId: agent.id, source: 'ci', spec: makeSpec() }).priority, 50);
+  assert.equal(jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() }).priority, 60);
+  assert.equal(jobs.create({ agentId: agent.id, source: 'ci', spec: makeSpec({ priority: 90 }) }).priority, 90);
+});
+
+test('duration is stored once when a job finishes, from its start; none if it never ran', () => {
+  const { registry, agents, jobs, scheduler, db } = buildTestServices(),
+    { agent } = agents.create({ name: 'ci', kind: 'ci' }),
+    r = registerResource(registry, { name: 'lab-sw-01', type: 'sw' });
+  registry.heartbeat(r.id, { state: 'idle' });
+
+  const ran = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  scheduler.runPass();
+  jobs.setState(ran.id, JOB_STATES.RUNNING);
+  db.prepare('UPDATE jobs SET started_at = ? WHERE id = ?').run(new Date(Date.now() - 125e3).toISOString(), ran.id);
+  jobs.setState(ran.id, JOB_STATES.PASSED);
+  assert.equal(jobs.get(ran.id).duration_sec, 125);
+
+  const never = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  jobs.cancel(never.id, { isAdmin: true });
+  assert.equal(jobs.get(never.id).duration_sec, null);
+});
+
 test('admin resetQueue cancels every active job and leaves finished ones alone', () => {
   const { registry, agents, jobs, scheduler } = buildTestServices(),
     { agent } = agents.create({ name: 'ci', kind: 'ci' }),
@@ -419,6 +447,84 @@ test('a job with target.client is rejected (422) when the client is unknown or c
   );
 });
 
+test('removing a resource keeps its job history by name and cancels jobs pinned to it', () => {
+  const { registry, agents, jobs, scheduler } = buildTestServices(),
+    { agent } = agents.create({ name: 'ci', kind: 'ci' }),
+    r = registerResource(registry, { name: 'lab-old', type: 'sw' });
+  registry.heartbeat(r.id, { state: 'idle' });
+
+  const done = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  scheduler.runPass();
+  assert.throws(() => registry.remove(r.id), /working on job/); // ASSIGNED: refused
+  jobs.setState(done.id, JOB_STATES.PASSED);
+  registry.heartbeat(r.id, { state: 'busy' }); // keep it from taking the pinned job below
+
+  const pinned = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec({ target: { type: 'sw', client: r.id } }) });
+  registry.remove(r.id);
+  assert.deepEqual(jobs.cancelPinnedTo(r.id, 'removed'), [pinned.id]);
+
+  assert.equal(registry.get(r.id), undefined);
+  const kept = jobs.get(done.id);
+  assert.equal(kept.resource_id, null);
+  assert.equal(kept.resource_name, 'lab-old');
+  assert.equal(jobs.get(pinned.id).state, JOB_STATES.CANCELED);
+  assert.throws(() => registry.remove(r.id), /Unknown resource/);
+});
+
+test('removing a resource running a job: stops the job now, removes once the Client confirms', () => {
+  const { registry, agents, jobs, scheduler } = buildTestServices(),
+    { agent } = agents.create({ name: 'ci', kind: 'ci' }),
+    r = registerResource(registry, { name: 'lab-busy', type: 'sw' });
+  registry.heartbeat(r.id, { state: 'idle' });
+  const running = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  scheduler.runPass();
+  jobs.setState(running.id, JOB_STATES.RUNNING);
+
+  assert.throws(() => jobs.removeResource(r.id), /running job/); // needs stopJob
+
+  const res = jobs.removeResource(r.id, { stopJob: true });
+  assert.equal(res.pending, true);
+  assert.equal(res.stoppedJob, running.id);
+  assert.equal(jobs.get(running.id).state, JOB_STATES.CANCELED);
+  assert.ok(registry.get(r.id).remove_requested_at); // still there: the Client hasn't heard yet
+
+  // Pending removal takes no new work, even once it reports idle.
+  registry.heartbeat(r.id, { state: 'idle' });
+  const next = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  scheduler.runPass();
+  assert.equal(jobs.get(next.id).state, JOB_STATES.QUEUED);
+
+  jobs.completeRemoval(r.id); // what the heartbeat route does on the Client's "no active job"
+  assert.equal(registry.get(r.id), undefined);
+  assert.equal(jobs.get(running.id).resource_name, 'lab-busy');
+});
+
+test('the sweeper finishes a pending removal whose Client never confirms', () => {
+  const { registry, agents, jobs, scheduler, heartbeatMonitor, db } = buildTestServices(),
+    { agent } = agents.create({ name: 'ci', kind: 'ci' }),
+    r = registerResource(registry, { name: 'lab-silent', type: 'sw' });
+  registry.heartbeat(r.id, { state: 'idle' });
+  jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
+  scheduler.runPass();
+  jobs.removeResource(r.id, { stopJob: true });
+
+  heartbeatMonitor.sweepRemovals();
+  assert.ok(registry.get(r.id)); // not timed out yet
+
+  db.prepare('UPDATE resources SET remove_requested_at = ? WHERE id = ?').run(new Date(Date.now() - 3600e3).toISOString(), r.id);
+  heartbeatMonitor.sweepRemovals();
+  assert.equal(registry.get(r.id), undefined);
+});
+
+test('a removed Client re-registers as a fresh resource under the same name', () => {
+  const { registry } = buildTestServices(),
+    r = registerResource(registry, { name: 'lab-back', type: 'sw', clientId: 'c-back' });
+  registry.remove(r.id);
+  const again = registerResource(registry, { name: 'lab-back', type: 'sw', clientId: 'c-back' });
+  assert.notEqual(again.id, r.id);
+  assert.equal(again.name, 'lab-back');
+});
+
 test('a resource can belong to several groups at once', () => {
   const { registry, groups } = buildTestServices(),
     g1 = groups.create({ name: 'g1' }),

package/views/index.pug

@@ -30,7 +30,7 @@ block content
           .card-body
             h5.card-title= r.name
             p.card-text.mb-1
-              +resourceBadge(r.status)
+              +resourceBadge(r.status, r.remove_requested_at)
               |
               = ' ' + r.type.toUpperCase()
             if r.busy_source
@@ -41,5 +41,9 @@ block content
   each r in resources
     +resourceCard(r, groupsById, '/')
 
+  if user && user.role === 'admin'
+    +removeResourceModal()
+
 block scripts
   script(src="/js/resource-card.js")
+  script(src="/js/remove-resource.js")

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,23 @@ 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 Finished
+        +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
       each j in jobs
         tr
@@ -40,6 +46,64 @@ block content
           td.text-uppercase= j.source
           td= j.spec.user || '—'
           td: +jobBadge(j.state)
-          td= j.resource ? j.resource.name : '—'
+          td= j.resource ? j.resource.name : j.resource_name ? `${j.resource_name} (removed)` : '—'
           td= fmtDate(j.created_at)
-          td= fmtDate(j.finished_at)
+          td(title=j.finished_at ? `Finished ${fmtDate(j.finished_at)}` : null)= j.duration_sec != null ? fmtDuration(j.duration_sec * 1000) : '—'
+          if canManage
+            td.text-end
+              if j.active
+                form.d-inline(
+                  method="post"
+                  action=`/jobs/${j.id}/cancel`
+                  data-confirm=`Cancel job ${j.id}?`
+                  onsubmit="return confirm(this.dataset.confirm)"
+                )
+                  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/jobs/show.pug

@@ -9,7 +9,7 @@ block content
       |
       +jobBadge(job.state)
     if canCancel
-      form(method="post" action=`/jobs/${job.id}/cancel`)
+      form(method="post" action=`/jobs/${job.id}/cancel` onsubmit=`return confirm('Cancel job ${job.id}?')`)
         button.btn.btn-outline-danger.btn-sm(type="submit") Cancel
 
   dl.row
@@ -19,7 +19,7 @@ block content
       dt.col-sm-2 User
       dd.col-sm-10= job.spec.user
     dt.col-sm-2 Resource
-    dd.col-sm-10= job.resource ? job.resource.name : '—'
+    dd.col-sm-10= job.resource ? job.resource.name : job.resource_name ? `${job.resource_name} (removed)` : '—'
     dt.col-sm-2 Target
     dd.col-sm-10= `${job.spec.target.type} — ${(job.spec.target.labels || []).join(', ')}`
     if job.spec.target.client
@@ -27,6 +27,9 @@ block content
       dd.col-sm-10= pinnedClient ? pinnedClient.name : job.spec.target.client
     dt.col-sm-2 Created
     dd.col-sm-10= fmtDate(job.created_at)
+    if job.duration_sec != null
+      dt.col-sm-2 Duration
+      dd.col-sm-10(title=`Finished ${fmtDate(job.finished_at)}`)= fmtDuration(job.duration_sec * 1000)
     if job.message
       dt.col-sm-2 Message
       dd.col-sm-10= job.message

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