@andrian.yablonskyy/thub-coordinator 1.0.38 → 1.0.39

package/bin/thub-admin.js

@@ -30,7 +30,6 @@ const { loadConfig } = require('../src/config'),
   { createAgentsService } = require('../src/services/agents'),
   { createGroupsService } = require('../src/services/groups'),
   { createAdminUsersService } = require('../src/services/admin-users'),
-  { createArtifactsService } = require('../src/services/artifacts'),
   { createJobsService } = require('../src/services/jobs'),
   { createCleanupService } = require('../src/services/cleanup'),
   { generateToken } = require('../src/services/tokens'),
@@ -46,7 +45,7 @@ function usage(){
   thub-admin resource maintenance <resourceId> --on|--off
   thub-admin jobs reset --yes     Cancel every queued/assigned/preparing/running job
   thub-admin jobs clean --yes [--before "dd/mm/yyyy HH:MM:SS"]
-                                  Permanently delete finished jobs (with logs and artifacts) and
+                                  Permanently delete finished jobs (with their logs) and
                                   history from before then (local time; default: now), then
                                   compact the database file
   thub-admin group add <name> [--comment <text>]
@@ -134,8 +133,7 @@ function main(){
     registry = createRegistryService(db, { bus, events }),
     agents = createAgentsService(db, { events }),
     adminUsers = createAdminUsersService(db),
-    artifacts = createArtifactsService(db, { config }),
-    jobs = createJobsService(db, { bus, events, registry, artifacts, config }),
+    jobs = createJobsService(db, { bus, events, registry, config }),
     groups = createGroupsService(db, { events, registry });
 
   if (cmd === 'create-admin'){
@@ -193,7 +191,7 @@ function main(){
   if (cmd === 'jobs' && sub === 'clean'){
     const { flags } = parseFlags(rest);
     if (!flags.yes){
-      console.error('This permanently deletes finished jobs and their logs/artifacts. Re-run with --yes to confirm.');
+      console.error('This permanently deletes finished jobs and their logs. Re-run with --yes to confirm.');
       process.exit(4);
     }
     const before = flags.before ? parseDateTime(flags.before) : new Date();

package/config.json

@@ -20,11 +20,6 @@
     "maxTimeoutSec": 14400
   },
   "retention": {
-    "logRetentionDays": 14,
-    "artifactRetentionDays": 30
-  },
-  "artifacts": {
-    "maxUploadMb": 512,
-    "linkTtlHours": 168
+    "jobRetention": "forever"
   }
 }

package/package.json

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

package/public/js/log-viewer.js

@@ -1,6 +1,6 @@
 /**
  * @file        packages/coordinator/public/js/log-viewer.js
- * @description Dashboard: streams or fetches a job's log output into the log viewer pane
+ * @description Dashboard: a job's log in the log viewer pane — loaded from its end, earlier lines as you scroll up, live lines streamed
  *
  * @author      Andrian Yablonskyy
  * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
@@ -21,7 +21,11 @@
   const jobId = pre.dataset.jobId,
     jobActive = pre.dataset.jobActive === 'true',
     filter = document.getElementById('stream-filter'),
-    lines = [],
+    info = document.getElementById('log-info'),
+    loadAllButton = document.getElementById('log-load-all'),
+    PAGE = 1000, // lines per page (routes.js LOG_PAGE)
+    PAGE_ALL = 5000, // per request when loading everything
+    NEAR_TOP_PX = 150,
     // Same dd/mm/yyyy HH:MM:SS, 24-hour format and profile time zone as
     // every server-rendered date (thub-common formatDateTime).
     timeFormat = new Intl.DateTimeFormat('en-GB', {
@@ -35,6 +39,16 @@
       hourCycle: 'h23'
     });
 
+  // What's loaded, oldest first: a window ending at the log's end. `firstSeq`
+  // is where the next earlier page ends; `total` counts every line the job
+  // has (loaded or not), live lines included.
+  let lines = [],
+    firstSeq = null,
+    hasMore = false,
+    total = 0,
+    lastSeq = 0, // newest log line we have (for the live stream to follow on)
+    loading = false;
+
   function fmtTime(iso){
     const d = new Date(iso);
     if (Number.isNaN(d.getTime())){
@@ -44,8 +58,28 @@
     return `${p.day}/${p.month}/${p.year} ${p.hour}:${p.minute}:${p.second}`;
   }
 
-  // Search (views/mixins/log-viewer.pug): case-insensitive, literal text.
-  // Matches are <mark>ed; `current` is the one the arrows step to.
+  const number = (n) => n.toLocaleString('en-GB');
+
+  function updateInfo(){
+    const logLines = lines.filter((l) => l.seq !== undefined).length;
+    if (loading){
+      info.textContent = 'Loading earlier lines…';
+    }
+    else if (!total){
+      info.textContent = jobActive ? 'No output yet.' : 'This job produced no output.';
+    }
+    else if (hasMore){
+      info.textContent = `Showing the last ${number(logLines)} of ${number(total)} lines — scroll up for earlier ones.`;
+    }
+    else {
+      info.textContent = `All ${number(total)} lines.`;
+    }
+    loadAllButton.hidden = !hasMore || loading;
+  }
+
+  // Search (views/mixins/log-viewer.pug): case-insensitive, literal text,
+  // over the loaded lines. Matches are <mark>ed; `current` is the one the
+  // arrows step to.
   const search = document.getElementById('log-search'),
     onlyMatching = document.getElementById('log-search-only'),
     count = document.getElementById('log-search-count'),
@@ -62,7 +96,7 @@
   function showCurrent(scroll){
     hits.forEach((el, i) => el.classList.toggle('current', i === current));
     if (current >= 0){
-      count.textContent = `${current + 1} / ${hits.length}`;
+      count.textContent = `${current + 1} / ${hits.length}${hasMore ? ' loaded' : ''}`;
       if (scroll){
         const el = hits[current];
         pre.scrollTop = el.offsetTop - pre.clientHeight / 2;
@@ -78,22 +112,42 @@
     showCurrent(true);
   }
 
-  // `live`: re-rendered for a newly streamed line — keep the reader's place
-  // while searching; without a search, follow the end of the log as before.
-  function render({ live = false } = {}){
+  // `mode` says what changed, and so where the view should stay:
+  //   reset   — first load, a new search or filter: the end (or first match)
+  //   live    — a streamed line: follow the end only if the reader is there
+  //   prepend — earlier lines loaded above: keep the same lines in view
+  function render(mode = 'reset'){
     const wanted = filter.value,
       query = search.value.trim(),
+      atBottom = pre.scrollHeight - pre.scrollTop - pre.clientHeight < 30,
+      fromBottom = pre.scrollHeight - pre.scrollTop,
+      scrollTop = pre.scrollTop,
+      hitsBefore = hits.length,
       shown = lines
         .filter((l) => !wanted || l.stream === wanted)
         .map((l) => `[${fmtTime(l.ts)}] [${l.stream}] ${l.line}`);
 
+    function place(){
+      if (mode === 'prepend'){
+        pre.scrollTop = pre.scrollHeight - fromBottom;
+      }
+      else if (mode === 'reset' || atBottom){
+        pre.scrollTop = pre.scrollHeight;
+      }
+      else {
+        pre.scrollTop = scrollTop;
+      }
+    }
+
+    updateInfo();
     if (!query){
       pre.textContent = shown.join('\n');
       hits = [];
       current = -1;
       count.hidden = true;
       prev.disabled = next.disabled = true;
-      pre.scrollTop = pre.scrollHeight;
+      place();
+      fillIfShort();
       return;
     }
 
@@ -112,7 +166,6 @@
         out.push(html + escapeHtml(text.slice(last)));
       }
     }
-    const scrollTop = pre.scrollTop;
     pre.innerHTML = out.join('\n');
     hits = [...pre.querySelectorAll('mark.thub-log-hit')];
     count.hidden = false;
@@ -120,18 +173,23 @@
     prev.disabled = next.disabled = hits.length < 2;
     if (!hits.length){
       current = -1;
-      count.textContent = 'No matches';
+      count.textContent = hasMore ? 'No matches in loaded lines' : 'No matches';
+      place();
+      fillIfShort();
       return;
     }
-    if (live){
-      current = Math.min(Math.max(current, 0), hits.length - 1);
-      showCurrent(false);
-      pre.scrollTop = scrollTop;
-    }
-    else {
+    if (mode === 'reset'){
       current = 0;
       showCurrent(true);
     }
+    else {
+      // Earlier lines add their matches in front: the same match moves down.
+      current = mode === 'prepend' ? current + (hits.length - hitsBefore) : current;
+      current = Math.min(Math.max(current, 0), hits.length - 1);
+      showCurrent(false);
+      place();
+    }
+    fillIfShort();
   }
 
   // Streamed lines can arrive in bursts: render at most once per frame.
@@ -142,10 +200,75 @@
     queued = true;
     requestAnimationFrame(() => {
       queued = false;
-      render({ live: true });
+      render('live');
     });
   }
 
+  // --- loading pages ------------------------------------------------------
+  async function fetchPage(before, limit){
+    const qs = new URLSearchParams({ limit: String(limit) });
+    if (before){
+      qs.set('before', String(before));
+    }
+    const res = await fetch(`/jobs/${encodeURIComponent(jobId)}/logs?${qs}`, { cache: 'no-store' });
+    if (!res.ok){
+      throw new Error(`HTTP ${res.status}`);
+    }
+    return res.json();
+  }
+
+  function absorb(page, where){
+    const fetched = page.lines;
+    if (fetched.length){
+      firstSeq = fetched[0].seq;
+    }
+    lines = where === 'prepend' ? [...fetched, ...lines] : fetched;
+    if (where !== 'prepend' && fetched.length){
+      lastSeq = fetched.at(-1).seq;
+    }
+    hasMore = page.hasMore;
+    total = Math.max(total, page.total);
+  }
+
+  async function loadEarlier(limit = PAGE){
+    if (loading || !hasMore){
+      return;
+    }
+    loading = true;
+    updateInfo();
+    try {
+      absorb(await fetchPage(firstSeq, limit), 'prepend');
+    }
+    catch {
+      info.textContent = 'Couldn’t load earlier lines — scroll up to try again.';
+      loading = false;
+      return;
+    }
+    loading = false;
+    render('prepend');
+  }
+
+  async function loadAll(){
+    while (hasMore && !loading){
+      await loadEarlier(PAGE_ALL);
+    }
+  }
+
+  // A filter or "only matching lines" can leave too little to scroll: keep
+  // loading earlier pages until there's something to scroll, or nothing left.
+  function fillIfShort(){
+    if (hasMore && !loading && pre.scrollHeight <= pre.clientHeight + NEAR_TOP_PX){
+      loadEarlier();
+    }
+  }
+
+  pre.addEventListener('scroll', () => {
+    if (pre.scrollTop < NEAR_TOP_PX){
+      loadEarlier();
+    }
+  }, { passive: true });
+  loadAllButton.addEventListener('click', loadAll);
+
   let typing;
   search.addEventListener('input', () => {
     clearTimeout(typing);
@@ -167,43 +290,52 @@
   onlyMatching.addEventListener('change', () => render());
   filter.addEventListener('change', () => render());
 
-  // Already finished when the page loaded: the output will never change
-  // again, so just fetch it once — no EventSource, no live connection, no
-  // reload. (Opening a stream here used to trigger an auto-reload once it
-  // immediately got the job's "end" event, which reloaded the page, which
-  // re-opened the stream, which reloaded again — an infinite loop for
-  // anyone viewing a finished job.)
-  if (!jobActive){
-    fetch(`/jobs/${jobId}/logs`)
-      .then((r) => r.json())
-      .then(({ lines: fetched }) => {
-        lines.push(...fetched);
-        render();
-      })
-      .catch(() => {});
-    return;
-  }
+  // --- start: the end of the log, then (active job) live lines after it ----
+  (async () => {
+    try {
+      absorb(await fetchPage(null, PAGE), 'replace');
+    }
+    catch {
+      info.textContent = 'Couldn’t load the log — reload the page to try again.';
+      return;
+    }
+    render();
 
-  const source = new EventSource(`/jobs/${jobId}/stream`);
-  source.addEventListener('log', (e) => {
-    lines.push(JSON.parse(e.data));
-    renderLive();
-  });
-  source.addEventListener('state', (e) => {
-    const { state, resource } = JSON.parse(e.data);
-    lines.push({ ts: new Date().toISOString(), stream: 'state', line: `-> ${state}${resource ? ' on ' + resource : ''}` });
-    renderLive();
-  });
-  source.addEventListener('end', (e) => {
-    const { state } = JSON.parse(e.data);
-    lines.push({ ts: new Date().toISOString(), stream: 'state', line: `job finished: ${state}` });
-    renderLive();
-    source.close();
-    // The job was active when we opened this page and just finished —
-    // reload once to pick up the now-final badge/artifacts list.
-    setTimeout(() => window.location.reload(), 1500);
-  });
-  source.onerror = () => {
-    // EventSource auto-reconnects; nothing to do here.
-  };
+    // Already finished when the page loaded: the output will never change
+    // again — no EventSource, no live connection. (Opening a stream here used
+    // to reload the page on its immediate "end" event, forever.)
+    if (!jobActive){
+      return;
+    }
+    // Live lines start right after what's loaded; on a reconnect the
+    // browser resumes from the last one it got (Last-Event-ID).
+    const source = new EventSource(`/jobs/${encodeURIComponent(jobId)}/stream?after=${lastSeq}`);
+    source.addEventListener('log', (e) => {
+      const seq = Number(e.lastEventId) || undefined;
+      if (seq && seq <= lastSeq){
+        return; // already have it
+      }
+      lastSeq = seq ?? lastSeq;
+      lines.push({ ...JSON.parse(e.data), seq });
+      total += 1;
+      renderLive();
+    });
+    source.addEventListener('state', (e) => {
+      const { state, resource } = JSON.parse(e.data);
+      lines.push({ ts: new Date().toISOString(), stream: 'state', line: `-> ${state}${resource ? ' on ' + resource : ''}` });
+      renderLive();
+    });
+    source.addEventListener('end', (e) => {
+      const { state } = JSON.parse(e.data);
+      lines.push({ ts: new Date().toISOString(), stream: 'state', line: `job finished: ${state}` });
+      renderLive();
+      source.close();
+      // The job was active when we opened this page and just finished —
+      // reload once to pick up the now-final badge and details.
+      setTimeout(() => window.location.reload(), 1500);
+    });
+    source.onerror = () => {
+      // EventSource auto-reconnects; nothing to do here.
+    };
+  })();
 })();

package/scripts/install-default-config.js

@@ -1,7 +1,7 @@
 /**
  * @file        scripts/install-default-config.js
  * @description npm postinstall: on a real global install, creates the Coordinator's directory layout
- *              (~/.config/thub, ~/.thub and its artifacts/avatars/work subdirs) and, if it
+ *              (~/.config/thub, ~/.thub and its avatars/work subdirs) and, if it
  *              doesn't already exist, ~/.config/thub/coordinator.json with every default option and
  *              a freshly generated sessionSecret (README §12, §13)
  *

package/scripts/install-target.js

@@ -52,7 +52,7 @@ function resolveTargetUser(){
 }
 
 // Default layout (README §13): config under ~/.config/thub, runtime data
-// (SQLite DB, uploaded artifacts, avatars, work files) under ~/.thub.
+// (SQLite DB, avatars, work files) under ~/.thub.
 // An existing coordinator.json's own dataDir wins over the default, so a
 // re-install prepares (and the systemd unit allows writes to) the
 // directory the Coordinator will really use.
@@ -69,7 +69,7 @@ function targetPaths(user){
     // Written by the dashboard's "Update app" button, watched by
     // thub-coordinator-update.path (README §10.2).
     updateRequestFile: path.join(dataDir, 'update-request.json'),
-    dataSubdirs: ['artifacts', 'avatars', 'work'].map((d) => path.join(dataDir, d))
+    dataSubdirs: ['avatars', 'work'].map((d) => path.join(dataDir, d))
   };
 }
 

package/src/api/admin.js

@@ -134,7 +134,7 @@ function createAdminRouter({ services }){
     res.json({ canceled });
   });
 
-  // Permanently deletes finished jobs and their logs/artifacts (§13.1).
+  // Permanently deletes finished jobs and their logs (§13.1).
   // Database cleanup (§9): optional `before` (ISO 8601; default now) —
   // finished jobs that ended before it, older history, then VACUUM.
   router.post('/jobs/clean-history', (req, res) => {

package/src/api/agent.js

@@ -80,19 +80,13 @@ function createAgentRouter({ services, config }){
   });
 
   router.get('/jobs/:id/logs/stream', auth, (req, res) => {
-    attachJobStream(req, res, { jobId: req.params.id, services, config });
+    attachJobStream(req, res, { jobId: req.params.id, services });
   });
 
+  // No artifacts are stored any more (README §9); an Agent older than that
+  // still asks after a finished job's `thub status`, so answer "none".
   router.get('/jobs/:id/artifacts', auth, (req, res) => {
-    const artifacts = services.artifacts.listForJob(req.params.id).map((a) => ({
-      id: a.id,
-      name: a.name,
-      size: a.size,
-      sha256: a.sha256,
-      contentType: a.content_type,
-      url: services.artifacts.signedUrl(a)
-    }));
-    res.json({ artifacts });
+    res.json({ artifacts: [] });
   });
 
   router.get('/resources', auth, (req, res) => {

package/src/api/resource.js

@@ -14,12 +14,9 @@
 'use strict';
 
 const express = require('express'),
-  multer = require('multer'),
   { requireRole, requireJoinKey, appVersion } = require('../auth'),
   { JOB_STATES } = require('@andrian.yablonskyy/thub-common');
 
-const upload = multer({ dest: require('node:os').tmpdir() });
-
 function requireOwnResource(req, res, next){
   if (req.resource.id !== req.params.id){
     return res.status(403).json({ error: 'Token does not match resource' });
@@ -211,14 +208,12 @@ function createResourceRouter({ services, config }){
     }
   });
 
-  router.post('/jobs/:id/artifacts', auth, requireOwnJob(services), upload.any(), (req, res, next) => {
-    try {
-      const stored = services.artifacts.storeUploaded(req.params.id, req.files || []);
-      res.status(201).json({ artifacts: stored.map((a) => ({ id: a.id, name: a.name, size: a.size })) });
-    }
-    catch (err){
-      next(err);
-    }
+  // Artifacts are no longer stored on the Coordinator (README §9). A Client
+  // older than that still uploads its results after each job and would end
+  // the job as ERROR on a 404, so accept the upload and discard it unread.
+  router.post('/jobs/:id/artifacts', auth, requireOwnJob(services), (req, res) => {
+    req.resume();
+    req.on('end', () => res.status(201).json({ artifacts: [] }));
   });
 
   router.post('/jobs/:id/result', auth, requireOwnJob(services), (req, res, next) => {

package/src/api/sse.js

@@ -15,11 +15,12 @@
 
 const { TERMINAL_JOB_STATES, JOB_STATES } = require('@andrian.yablonskyy/thub-common');
 
-const WAITING_CHECK_MS = 15_000;
+const WAITING_CHECK_MS = 15_000,
+  REPLAY_PAGE = 2000;
 
 // §6.4: log / state / end events, resumable via Last-Event-ID (§7: "the
 // Agent reconnects with exponential backoff and resumes from the last seq").
-function attachJobStream(req, res, { jobId, services, config }){
+function attachJobStream(req, res, { jobId, services }){
   const { jobs, logs, registry, bus } = services,
 
     job = jobs.get(jobId);
@@ -47,17 +48,19 @@ function attachJobStream(req, res, { jobId, services, config }){
     res.write(`data: ${JSON.stringify(data)}\n\n`);
   }
 
-  for (const line of logs.listSince(jobId, afterSeq)){
-    writeEvent('log', { ts: line.ts, stream: line.stream, line: line.line }, line.seq);
-  }
-
-  function artifactsUrl(){
-    return `${config.publicUrl}/jobs/${jobId}#artifacts`;
+  // Replay everything after `afterSeq`, in pages (listSince stops at 500 a
+  // call — replaying one page used to skip lines 501.. of a longer log). All
+  // synchronous, so no live line can slip in between replay and subscribing.
+  for (let seq = afterSeq, page; (page = logs.listSince(jobId, seq, REPLAY_PAGE)).length;){
+    for (const line of page){
+      writeEvent('log', { ts: line.ts, stream: line.stream, line: line.line }, line.seq);
+    }
+    seq = page.at(-1).seq;
   }
 
   const current = jobs.get(jobId);
   if (TERMINAL_JOB_STATES.has(current.state)){
-    writeEvent('end', { state: current.state, artifactsUrl: artifactsUrl() });
+    writeEvent('end', { state: current.state });
     return res.end();
   }
 
@@ -97,7 +100,7 @@ function attachJobStream(req, res, { jobId, services, config }){
       if (evt.jobId !== jobId){
         return;
       }
-      writeEvent('end', { state: evt.state, artifactsUrl: artifactsUrl() });
+      writeEvent('end', { state: evt.state });
       cleanup();
       res.end();
     };

package/src/config.js

@@ -28,6 +28,12 @@ const DEFAULTS = {
   trustProxy: 'loopback',
   dataDir: path.join(process.cwd(), '.data'),
   sessionSecret: 'dev-only-change-me',
+  session: {
+    // The dashboard session cookie's Secure flag (server.js cookieSecure):
+    // "auto" = Secure whenever publicUrl is https:// (else per request:
+    // Secure only on a connection that is itself HTTPS); true / false force it.
+    secureCookie: 'auto'
+  },
   // Shared secret Clients present to self-register (see api/resource.js).
   // null disables auto-registration entirely — set it explicitly to turn it on.
   clientJoinKey: null,
@@ -46,19 +52,16 @@ const DEFAULTS = {
     defaultTimeoutSec: 1800,
     maxTimeoutSec: 14400
   },
+  // logRetentionDays, artifactRetentionDays and the `artifacts` section of
+  // older configs are no longer read: a job's log lines live as long as the
+  // job, and the Coordinator stores no artifacts (README §9).
   retention: {
-    logRetentionDays: 14,
-    artifactRetentionDays: 30,
-    // How long a finished job (with its logs, artifacts and events) is kept
+    // How long a finished job (with its logs and events) is kept
     // before the hourly retention task wipes it (services/cleanup.js):
     // 1w | 2w | 1m | 3m | 6m | forever. `forever` keeps everything until a
     // manual cleanup (dashboard Clean up database / thub-admin jobs clean).
     jobRetention: 'forever'
   },
-  artifacts: {
-    maxUploadMb: 512,
-    linkTtlHours: 168
-  },
   // New-version check of the Coordinator/Agent/Client packages (README
   // §10.2), every 15 minutes so a new Coordinator's "Update app" button
   // shows up promptly. 0 disables the periodic check; registry null = the
@@ -122,6 +125,12 @@ function loadConfig(configPath = process.env.THUB_COORDINATOR_CONFIG){
     config.clientJoinKey = process.env.THUB_CLIENT_JOIN_KEY;
   }
 
+  if (![true, false, 'auto'].includes(config.session.secureCookie)){
+    throw new Error(
+      `session.secureCookie must be "auto", true or false (got ${JSON.stringify(config.session.secureCookie)}) in ${candidate || 'the config'}`
+    );
+  }
+
   if (!Object.hasOwn(JOB_RETENTION, config.retention.jobRetention)){
     throw new Error(
       `retention.jobRetention must be one of: ${Object.keys(JOB_RETENTION).join(', ')} ` +
@@ -136,12 +145,10 @@ function loadConfig(configPath = process.env.THUB_COORDINATOR_CONFIG){
   config.host = host;
   config.port = Number(port);
   config.dbPath = path.join(config.dataDir, 'thub.db');
-  config.artifactsDir = path.join(config.dataDir, 'artifacts');
   config.workDir = path.join(config.dataDir, 'work');
   config.avatarsDir = path.join(config.dataDir, 'avatars');
 
   ensureWritableDir(config.dataDir, config.configPath);
-  ensureWritableDir(config.artifactsDir, config.configPath);
   ensureWritableDir(config.avatarsDir, config.configPath);
 
   return config;

package/src/db/migrations/022_add_sessions.sql

@@ -0,0 +1,10 @@
+-- Dashboard sessions (services/session-store.js), instead of express-session's
+-- in-memory store: they survive a restart, and expired ones are pruned.
+-- `expires` is epoch milliseconds (the session cookie's own expiry).
+CREATE TABLE sessions (
+  sid TEXT PRIMARY KEY,
+  sess TEXT NOT NULL,
+  expires INTEGER NOT NULL
+);
+
+CREATE INDEX idx_sessions_expires ON sessions(expires);

package/src/db/migrations/023_drop_artifacts.sql

@@ -0,0 +1,4 @@
+-- Job artifacts are no longer uploaded to or stored on the Coordinator
+-- (README §9): Clients keep a job's files only in its workspace, which they
+-- delete when the job ends. server.js removes <dataDir>/artifacts on startup.
+DROP TABLE IF EXISTS artifacts;

package/src/dev/virtual.js

@@ -170,7 +170,7 @@ function seedHistory(services, agentId, resourceIds){
 // stay IDLE instead of going OUT_OF_SERVICE) and play out any job the
 // scheduler assigns them — accept, PREPARING, RUNNING with streamed log
 // lines, then a PASSED (mostly) or FAILED result — through the same
-// services the Client API uses, so SSE, durations and artifacts all work.
+// services the Client API uses, so SSE and durations all work.
 function startVirtualClients(services, config){
   const { registry, jobs, logs, bus } = services,
     intervalMs = config.heartbeat.intervalSec * 1000,