cogworker 0.1.0

data/lib/cogworker/web/routes/dead.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Cogworker
+  class Web
+    module Routes
+      # Lists jobs that exhausted their retries, with delete and retry
+      # (requeue) actions.
+      module Dead
+        CONTENT_ID = 'dead-content'
+
+        module_function
+
+        def registered(app)
+          app.get('/dead') do
+            content = Dead.render_content(request.script_name)
+            if hx_request?
+              content
+            else
+              Layout.wrap('Dead', Layout.poll_div(CONTENT_ID, request.script_name, 'dead', content),
+                          script_name: request.script_name)
+            end
+          end
+
+          app.post('/dead/delete') do
+            Cogworker.config.redis { |c| c.zrem(RedisKeys::DEAD, params['raw']) }
+            Dead.respond(self)
+          end
+
+          app.post('/dead/delete_all') do
+            Cogworker.config.redis { |c| c.del(RedisKeys::DEAD) }
+            Dead.respond(self)
+          end
+
+          # Puts the job back on its original queue for one more attempt —
+          # same "graduate out of this ZSET, back onto cogworker:queue:<q>"
+          # move `Routes::Retries#retry_now` does for `cogworker:retry`,
+          # and `Cogworker::Scheduled#graduate` does for both `cogworker:
+          # schedule`/`cogworker:retry`. `zrem` winning (not losing) is what
+          # actually gates the requeue: without it, two browser tabs (or a
+          # slow double-click) retrying the same entry at once could both
+          # see it and each push a copy. NOTE: for a single (non-Array)
+          # member, the `redis` gem's `#zrem` returns a **Boolean**, not the
+          # raw `1`/`0` integer reply — `== 1` would always be false here
+          # (`true == 1` is `false` in Ruby); check truthiness instead, the
+          # same way `Cogworker::Scheduled#graduate`'s `next unless won` does.
+          app.post('/dead/retry') do
+            raw = params['raw']
+            Cogworker.config.redis do |c|
+              if c.zrem(RedisKeys::DEAD, raw)
+                job = JSON.parse(raw)
+                c.sadd(RedisKeys::QUEUES, job['queue'])
+                c.lpush(RedisKeys.queue(job['queue']), raw)
+              end
+            end
+            Dead.respond(self)
+          end
+        end
+
+        # After an action, htmx gets the refreshed fragment swapped into
+        # #dead-content in place; a plain form submission (no JS) falls back
+        # to a normal redirect back to the full page.
+        def respond(action)
+          if action.hx_request?
+            render_content(action.request.script_name)
+          else
+            action.redirect(Layout.path(action.request.script_name, 'dead'))
+          end
+        end
+
+        def render_content(script_name)
+          # Newest DiedAt first — `zrevrange` (`cogworker:dead`'s score is
+          # the epoch it died at), not `zrange`.
+          entries = Cogworker.config.redis { |c| c.zrevrange(RedisKeys::DEAD, 0, -1, withscores: true) }
+          delete_path = Layout.path(script_name, 'dead/delete')
+          retry_path = Layout.path(script_name, 'dead/retry')
+          rows = entries.map do |raw, score|
+            job = JSON.parse(raw)
+            [job['jid'], Layout.h(job['class']), Layout.time_tag(score),
+             Layout.form_button(retry_path, 'raw', raw, 'retry', hx_target: "##{CONTENT_ID}", variant: :primary),
+             Layout.form_button(delete_path, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)]
+          end
+          delete_all_path = Layout.path(script_name, 'dead/delete_all')
+          delete_all_button = Layout.action_button(delete_all_path, 'delete all', hx_target: "##{CONTENT_ID}",
+                                                                                  variant: :danger)
+          %(<div class="mb-3 flex justify-end">#{delete_all_button}</div>) +
+            Layout.table(%w[JID Class DiedAt Retry Delete], rows, empty_message: 'No dead jobs.')
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::Dead)

data/lib/cogworker/web/routes/history.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Cogworker
+  class Web
+    module Routes
+      # NOTE: always spelled `Cogworker::History::*` below, fully
+      # qualified — a bare `History::Storage` from in here would resolve
+      # (via lexical nesting) to *this* module first, which has no
+      # `Storage`, not to the top-level `Cogworker::History`.
+      module History
+        STATUSES = %w[all success failed].freeze
+        # Vendored under assets/ag-grid/ (pinned to Community v32.3.9 — see
+        # CLAUDE.md) rather than fetched from jsdelivr, so this tab works
+        # fully offline like the rest of the Web UI.
+        AG_GRID_ASSETS = %w[ag-grid/ag-grid-community.min.js ag-grid/ag-grid.min.css
+                            ag-grid/ag-theme-alpine.min.css].freeze
+
+        module_function
+
+        def registered(app)
+          app.get('/history') do
+            status = History::STATUSES.include?(params['status']) ? params['status'] : 'all'
+            content = Routes::History.render_content(request.script_name, status)
+            if hx_request?
+              content
+            else
+              Layout.wrap('History', content, script_name: request.script_name,
+                                              extra_head: Routes::History.ag_grid_head(request.script_name))
+            end
+          end
+
+          # Polled from the browser (see `grid_script`'s `refreshRows`) to
+          # keep the grid live without a full-page/htmx fragment reload,
+          # which would tear down and rebuild the AG Grid instance (and lose
+          # its sort/filter/scroll state) on every tick.
+          app.get('/history/data') do
+            status = History::STATUSES.include?(params['status']) ? params['status'] : 'all'
+            entries, = Cogworker::History::Storage.page(status, 1, Cogworker::History.max_entries)
+            [200, { 'content-type' => 'application/json' }, [JSON.generate(entries)]]
+          end
+        end
+
+        def ag_grid_head(script_name)
+          js, grid_css, theme_css = AG_GRID_ASSETS.map { |rel| Layout.path(script_name, "assets/#{rel}") }
+          <<~HTML
+            <script src="#{js}"></script>
+            <link rel="stylesheet" href="#{grid_css}">
+            <link rel="stylesheet" href="#{theme_css}">
+          HTML
+        end
+
+        # Loads up to `Cogworker::History.max_entries` rows for the chosen
+        # filter in one shot and hands them to AG Grid, which does its own
+        # client-side sorting/per-column filtering/quick-search/pagination
+        # from there — retention (`max_entries`) already bounds this to a
+        # size AG Grid handles comfortably, so there's no need for the
+        # gem's own server-side paging on top of it.
+        def render_content(script_name, status)
+          entries, = Cogworker::History::Storage.page(status, 1, Cogworker::History.max_entries)
+          filters(script_name, status) + grid(entries, script_name, status)
+        end
+
+        def filters(script_name, current_status)
+          links = STATUSES.map { |status| filter_link(script_name, status, active: status == current_status) }.join
+          %(<div class="mb-4 flex gap-2">#{links}</div>)
+        end
+
+        def filter_link(script_name, status, active:)
+          classes = if active
+                      'bg-indigo-600 text-white'
+                    else
+                      'bg-gray-100 dark:bg-gray-800 text-gray-600 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-700'
+                    end
+          href = Layout.path(script_name, "history?status=#{status}")
+          %(<a href="#{href}" class="px-3 py-1 rounded-md text-sm font-medium #{classes}">#{Layout.h(status.capitalize)}</a>)
+        end
+
+        def grid(entries, script_name, status)
+          <<~HTML
+            <div id="history-grid" class="ag-theme-alpine" style="height: 70vh; width: 100%;"></div>
+
+            <dialog id="history-backtrace-dialog" class="rounded-lg p-0 max-w-2xl w-[90vw] bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100">
+              <div class="p-4">
+                <div class="flex justify-between items-center mb-3">
+                  <h3 class="font-semibold">Backtrace</h3>
+                  <button type="button" onclick="this.closest('dialog').close()"
+                          class="text-gray-400 hover:text-gray-600 dark:hover:text-gray-200">✕</button>
+                </div>
+                <pre id="history-backtrace-content" class="text-xs whitespace-pre-wrap max-h-[60vh] overflow-y-auto bg-gray-50 dark:bg-gray-950 p-3 rounded border border-gray-200 dark:border-gray-800"></pre>
+              </div>
+            </dialog>
+
+            #{grid_script(entries, script_name, status)}
+          HTML
+        end
+
+        def grid_script(entries, script_name, status)
+          data_url = Layout.path(script_name, "history/data?status=#{status}")
+          <<~HTML
+            <script>
+              (function () {
+                var dataUrl = #{Layout.json_for_script(data_url)};
+                var rowData = #{Layout.json_for_script(entries)};
+                var backtraces = {};
+                // The dialog leads with the error itself (class + message)
+                // and only then the backtrace — the grid's own Error column
+                // can be too narrow/truncated to read the full message, and
+                // clicking through to "just the backtrace" without it loses
+                // the one thing you're usually trying to look up.
+                function indexBacktraces() {
+                  backtraces = {};
+                  rowData.forEach(function (row) {
+                    if (!row.backtrace) return;
+                    var header = (row.error_class || 'Error') + ': ' + (row.error_message || '');
+                    backtraces[row.jid] = header + '\\n\\n' + row.backtrace.join('\\n');
+                  });
+                }
+                indexBacktraces();
+
+                window.cogworkerShowHistoryBacktrace = function (jid) {
+                  document.getElementById('history-backtrace-content').textContent = backtraces[jid] || '(no backtrace)';
+                  document.getElementById('history-backtrace-dialog').showModal();
+                };
+
+                function statusCellRenderer(p) {
+                  var ok = p.value === 'success';
+                  var classes = ok
+                    ? 'bg-green-100 text-green-800 dark:bg-green-900/40 dark:text-green-300'
+                    : 'bg-red-100 text-red-800 dark:bg-red-900/40 dark:text-red-300';
+                  return '<span class="px-2 py-0.5 rounded-full text-xs font-medium ' + classes + '">' + p.value + '</span>';
+                }
+
+                function errorValueGetter(p) {
+                  return p.data.error_class ? (p.data.error_class + ': ' + p.data.error_message) : '';
+                }
+
+                function errorCellRenderer(p) {
+                  if (!p.data.backtrace) return p.value || '';
+                  var span = document.createElement('span');
+                  span.textContent = p.value;
+                  span.className = 'text-red-700 dark:text-red-400 underline cursor-pointer';
+                  span.title = 'Click to view backtrace';
+                  span.addEventListener('click', function () { window.cogworkerShowHistoryBacktrace(p.data.jid); });
+                  return span;
+                }
+
+                // "2h 34m 23s 23ms" — each unit above the smallest one
+                // present only shows up once it (or a bigger one) is
+                // non-zero, so a typical sub-second job just reads "23ms"
+                // rather than "0h 0m 0s 23ms".
+                function formatDuration(ms) {
+                  ms = Math.max(0, Math.round(ms));
+                  var h = Math.floor(ms / 3600000);
+                  var m = Math.floor((ms % 3600000) / 60000);
+                  var s = Math.floor((ms % 60000) / 1000);
+                  var msRemainder = ms % 1000;
+                  var parts = [];
+                  if (h > 0) parts.push(h + 'h');
+                  if (h > 0 || m > 0) parts.push(m + 'm');
+                  if (h > 0 || m > 0 || s > 0) parts.push(s + 's');
+                  parts.push(msRemainder + 'ms');
+                  return parts.join(' ');
+                }
+
+                var columnDefs = [
+                  { field: 'finished_at', headerName: 'Finished', sort: 'desc', minWidth: 170,
+                    valueFormatter: function (p) { return window.cogworkerFormatTime(new Date(p.value * 1000)); } },
+                  { field: 'class', headerName: 'Class' },
+                  { field: 'queue', headerName: 'Queue' },
+                  { field: 'jid', headerName: 'JID', minWidth: 160 },
+                  { field: 'args', headerName: 'Args', minWidth: 200,
+                    valueFormatter: function (p) { return JSON.stringify(p.value); } },
+                  { field: 'status', headerName: 'Status', cellRenderer: statusCellRenderer, maxWidth: 120 },
+                  { headerName: 'Duration', maxWidth: 160,
+                    // `valueGetter` stays a plain millisecond Integer — AG
+                    // Grid sorts/filters on that raw value, `valueFormatter`
+                    // only changes what's *displayed*, so numeric sort order
+                    // ("23ms" before "1m 5s") stays correct regardless of
+                    // formatting.
+                    valueGetter: function (p) { return Math.round((p.data.finished_at - p.data.started_at) * 1000); },
+                    valueFormatter: function (p) { return formatDuration(p.value); } },
+                  { headerName: 'Error', minWidth: 260, valueGetter: errorValueGetter, cellRenderer: errorCellRenderer }
+                ];
+
+                var gridApi = agGrid.createGrid(document.getElementById('history-grid'), {
+                  columnDefs: columnDefs,
+                  rowData: rowData,
+                  defaultColDef: { sortable: true, filter: true, resizable: true, flex: 1 },
+                  pagination: true,
+                  paginationPageSize: #{Cogworker::Web.history_per_page},
+                  paginationPageSizeSelector: [10, 25, 50, 100]
+                });
+
+                if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+                  document.getElementById('history-grid').classList.add('ag-theme-alpine-dark');
+                }
+
+                // AG Grid isn't htmx-swapped (unlike Busy/Stats/Queues), so
+                // it needs its own poll — gated by the same global toggle —
+                // that replaces just `rowData` in place rather than
+                // reloading the fragment and tearing the grid instance down.
+                function refreshRows() {
+                  if (!window.cogworkerLiveUpdate) return;
+                  fetch(dataUrl, { headers: { 'Accept': 'application/json' } })
+                    .then(function (r) { return r.ok ? r.json() : null; })
+                    .then(function (data) {
+                      if (!data) return;
+                      rowData = data;
+                      indexBacktraces();
+                      gridApi.setGridOption('rowData', rowData);
+                    })
+                    .catch(function () {});
+                }
+                setInterval(refreshRows, #{Cogworker::Web.live_update_interval * 1000});
+              })();
+            </script>
+          HTML
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::History)

data/lib/cogworker/web/routes/periodic.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'fugit'
+require 'json'
+
+module Cogworker
+  class Web
+    module Routes
+      # Read-only: lists every registered `config.periodic { |mgr|
+      # mgr.register(...) }` entry and when it last/next fires. Sourced
+      # entirely from Redis (`periodic:schedule`/`periodic:last_slot:<pjid>`),
+      # not from any in-process `Periodic::Manager` — those are only
+      # published once an actual worker process's `Periodic::Ticker` has
+      # booted (see `Ticker#publish_schedule!`), so a Web-UI-only process
+      # (no worker ever started) shows the empty state here, same as Busy
+      # shows no processes with no worker running.
+      module Periodic
+        CONTENT_ID = 'periodic-content'
+
+        module_function
+
+        def registered(app)
+          app.get('/periodic') do
+            content = Routes::Periodic.render_content
+            if hx_request?
+              content
+            else
+              Layout.wrap('Periodic', Layout.poll_div(CONTENT_ID, request.script_name, 'periodic', content),
+                          script_name: request.script_name)
+            end
+          end
+        end
+
+        def render_content
+          schedule = Cogworker.config.redis { |c| c.hgetall(RedisKeys::PERIODIC_SCHEDULE) }
+          rows = schedule.map { |pjid, raw| row_for(pjid, JSON.parse(raw)) }
+          Layout.table(%w[Class Cron Args NextRun LastRun Unique], rows,
+                       empty_message: 'Nothing registered yet (no worker process has booted the periodic ' \
+                                      'scheduler — periodic jobs are published to Redis by ' \
+                                      'Periodic::Ticker on worker startup, not by the Web UI process).')
+        end
+
+        def row_for(pjid, entry)
+          [Layout.h(entry['class']), Layout.h(entry['cron']), Layout.h(entry['args'].to_json),
+           next_run_tag(entry['cron']), last_run_tag(pjid), unique_cell(entry['unique'])]
+        end
+
+        def next_run_tag(cron)
+          Layout.time_tag(Fugit::Cron.parse(cron)&.next_time(Time.now)&.to_t)
+        rescue StandardError
+          Layout.h('invalid cron')
+        end
+
+        def last_run_tag(pjid)
+          last_slot = Cogworker.config.redis { |c| c.get(RedisKeys.periodic_last_slot(pjid)) }
+          last_slot ? Layout.time_tag(last_slot.to_f) : %(<span class="text-gray-400 italic">never</span>)
+        end
+
+        def unique_cell(unique)
+          unique.nil? || unique.empty? ? '' : Layout.badge(unique, variant: :warning)
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::Periodic)

data/lib/cogworker/web/routes/queues.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Cogworker
+  class Web
+    module Routes
+      # Lists every known queue with its size/latency, and a per-queue drill
+      # down page listing that queue's pending jobs.
+      module Queues
+        CONTENT_ID = 'queues-content'
+        QUEUE_CONTENT_ID = 'queue-content'
+
+        module_function
+
+        def registered(app)
+          app.get('/queues') do
+            content = Queues.render_content(request.script_name)
+            if hx_request?
+              content
+            else
+              Layout.wrap('Queues', Layout.poll_div(CONTENT_ID, request.script_name, 'queues', content),
+                          script_name: request.script_name)
+            end
+          end
+
+          app.get('/queues/:name') do
+            name = url_params('name')
+            content = Queues.render_queue_content(name, request.script_name)
+            if hx_request?
+              content
+            else
+              Layout.wrap("Queue: #{Layout.h(name)}",
+                          Layout.poll_div(QUEUE_CONTENT_ID, request.script_name, "queues/#{name}", content),
+                          script_name: request.script_name)
+            end
+          end
+
+          # `raw` is the exact JSON string the job entry was pushed with —
+          # same "raw" identity `Routes::Dead`/`Routes::Retries` already key
+          # their own per-row delete off — so `Queue#delete` can `LREM` it
+          # back out of the list.
+          app.post('/queues/:name/delete') do
+            name = url_params('name')
+            Cogworker::Queue.new(name).delete(params['raw'])
+            Queues.respond(self, name)
+          end
+
+          app.post('/queues/:name/delete_all') do
+            name = url_params('name')
+            Cogworker::Queue.new(name).clear
+            Queues.respond(self, name)
+          end
+        end
+
+        # After an action, htmx gets the refreshed fragment swapped into
+        # #queue-content in place; a plain form submission (no JS) falls
+        # back to a normal redirect back to the queue's own page.
+        def respond(action, name)
+          if action.hx_request?
+            render_queue_content(name, action.request.script_name)
+          else
+            action.redirect(Layout.path(action.request.script_name, "queues/#{name}"))
+          end
+        end
+
+        def render_content(script_name)
+          names = Cogworker.config.redis { |c| c.smembers(RedisKeys::QUEUES) }.sort
+          rows = names.map do |name|
+            q = Cogworker::Queue.new(name)
+            link = Layout.path(script_name, "queues/#{Layout.h(name)}")
+            [%(<a class="text-indigo-600 dark:text-indigo-400 hover:underline font-medium" href="#{link}">#{Layout.h(name)}</a>),
+             q.size, q.latency.round(2)]
+          end
+          Layout.table(%w[Name Size Latency], rows, empty_message: 'No queues yet — push a job to create one.')
+        end
+
+        def render_queue_content(name, script_name)
+          delete_path = Layout.path(script_name, "queues/#{name}/delete")
+          rows = Cogworker::Queue.new(name).map do |r|
+            [r.jid, Layout.h(r.klass), Layout.h(r.args.to_s),
+             Layout.form_button(delete_path, 'raw', r.value, 'delete', hx_target: "##{QUEUE_CONTENT_ID}",
+                                                                       variant: :danger)]
+          end
+          delete_all_button(name, script_name, rows.empty?) +
+            Layout.table(%w[JID Class Args Delete], rows, empty_message: 'This queue is empty.')
+        end
+
+        # Nothing to bulk-delete once the queue is already empty.
+        def delete_all_button(name, script_name, empty)
+          return '' if empty
+
+          delete_all_path = Layout.path(script_name, "queues/#{name}/delete_all")
+          button = Layout.action_button(delete_all_path, 'delete all', hx_target: "##{QUEUE_CONTENT_ID}",
+                                                                       variant: :danger)
+          %(<div class="mb-3 flex justify-end">#{button}</div>)
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::Queues)

data/lib/cogworker/web/routes/retries.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Cogworker
+  class Web
+    module Routes
+      # Lists jobs currently scheduled for retry, with delete and
+      # retry-now (skip the backoff) actions.
+      module Retries
+        CONTENT_ID = 'retries-content'
+
+        module_function
+
+        def registered(app)
+          app.get('/retries') do
+            content = Retries.render_content(request.script_name)
+            if hx_request?
+              content
+            else
+              Layout.wrap('Retries', Layout.poll_div(CONTENT_ID, request.script_name, 'retries', content),
+                          script_name: request.script_name)
+            end
+          end
+
+          app.post('/retries/delete') do
+            Cogworker.config.redis { |c| c.zrem(RedisKeys::RETRY, params['raw']) }
+            Retries.respond(self)
+          end
+
+          app.post('/retries/retry_now') do
+            raw = params['raw']
+            Cogworker.config.redis do |c|
+              # For a single (non-Array) member, the `redis` gem's `#zrem`
+              # returns a **Boolean**, not the raw `1`/`0` integer reply —
+              # `== 1` is always false here (`true == 1` is `false` in
+              # Ruby); check truthiness instead, matching
+              # `Cogworker::Scheduled#graduate`'s `next unless won`.
+              if c.zrem(RedisKeys::RETRY, raw)
+                job = JSON.parse(raw)
+                c.sadd(RedisKeys::QUEUES, job['queue'])
+                c.lpush(RedisKeys.queue(job['queue']), raw)
+              end
+            end
+            Retries.respond(self)
+          end
+        end
+
+        # After an action, htmx gets the refreshed fragment swapped into
+        # #retries-content in place; a plain form submission (no JS) falls
+        # back to a normal redirect back to the full page.
+        def respond(action)
+          if action.hx_request?
+            render_content(action.request.script_name)
+          else
+            action.redirect(Layout.path(action.request.script_name, 'retries'))
+          end
+        end
+
+        def render_content(script_name)
+          entries = Cogworker.config.redis { |c| c.zrange(RedisKeys::RETRY, 0, -1) }
+          rows = entries.map do |raw|
+            job = JSON.parse(raw)
+            [job['jid'], Layout.h(job['class']), error_cell(job), delete_form(script_name, raw),
+             retry_now_form(script_name, raw)]
+          end
+          Layout.table(%w[JID Class Error Delete RetryNow], rows, empty_message: 'No retries pending.')
+        end
+
+        def error_cell(job)
+          <<~HTML
+            <div class="font-mono text-xs text-red-700 dark:text-red-400">#{Layout.h(job['error_class'])}</div>
+            <div class="text-xs text-gray-500 dark:text-gray-400 truncate max-w-xs">#{Layout.h(job['error_message'])}</div>
+          HTML
+        end
+
+        def delete_form(script_name, raw)
+          action = Layout.path(script_name, 'retries/delete')
+          Layout.form_button(action, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)
+        end
+
+        def retry_now_form(script_name, raw)
+          action = Layout.path(script_name, 'retries/retry_now')
+          Layout.form_button(action, 'raw', raw, 'retry now', hx_target: "##{CONTENT_ID}", variant: :primary)
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::Retries)

data/lib/cogworker/web/routes/save_session.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cogworker
+  class Web
+    module Routes
+      # Reserves POST /save_session as a real, always-present route — in
+      # practice an external auth middleware wrapping this app (via `Web.use`)
+      # typically intercepts this exact path itself before it ever reaches
+      # here (that's the whole point of it being a stable, bare, un-prefixed
+      # path an auth callback can bypass same-origin checks for). This is
+      # just a harmless default for when nothing else claims the path.
+      module SaveSession
+        def self.registered(app)
+          app.post('/save_session') { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::SaveSession)

data/lib/cogworker/web/routes/scheduled.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Cogworker
+  class Web
+    module Routes
+      # Lists jobs pushed with `perform_in`/`perform_at`, still waiting for
+      # their run-at time, with a delete action.
+      module Scheduled
+        CONTENT_ID = 'scheduled-content'
+
+        module_function
+
+        def registered(app)
+          app.get('/scheduled') do
+            content = Scheduled.render_content(request.script_name)
+            if hx_request?
+              content
+            else
+              Layout.wrap('Scheduled', Layout.poll_div(CONTENT_ID, request.script_name, 'scheduled', content),
+                          script_name: request.script_name)
+            end
+          end
+
+          app.post('/scheduled/delete') do
+            Cogworker.config.redis { |c| c.zrem(RedisKeys::SCHEDULE, params['raw']) }
+            if hx_request?
+              Scheduled.render_content(request.script_name)
+            else
+              redirect Layout.path(request.script_name, 'scheduled')
+            end
+          end
+        end
+
+        def render_content(script_name)
+          entries = Cogworker.config.redis { |c| c.zrange(RedisKeys::SCHEDULE, 0, -1, withscores: true) }
+          delete_path = Layout.path(script_name, 'scheduled/delete')
+          rows = entries.map do |raw, score|
+            job = JSON.parse(raw)
+            [job['jid'], Layout.h(job['class']), Layout.time_tag(score),
+             Layout.form_button(delete_path, 'raw', raw, 'delete', hx_target: "##{CONTENT_ID}", variant: :danger)]
+          end
+          Layout.table(%w[JID Class RunAt Delete], rows, empty_message: 'Nothing scheduled.')
+        end
+      end
+    end
+  end
+end
+
+Cogworker::Web.register(Cogworker::Web::Routes::Scheduled)