diff --git a/frontend/packages/dashboard/src/schedules.js b/frontend/packages/dashboard/src/schedules.js
new file mode 100644
index 00000000..7b2eabb3
--- /dev/null
+++ b/frontend/packages/dashboard/src/schedules.js
@@ -0,0 +1,1074 @@
+// Dashboard SCH3DUL3S tab — reminders + scheduled-prompts.
+//
+// Reminders (a separate sqlite table, not part of /api/state) and the
+// operator's scheduled prompts: the lists, the inline create row, the
+// per-row edit form, and the fire-now / cancel actions. Live updates
+// arrive via the `reminders_changed` / `schedules_changed` dashboard
+// events (wired into the entry's mutation dispatch table); the
+// tab-activation re-fetch is the cold-load / reconnect recovery path.
+//
+// Owns its own module state (the schedules list + edit-in-progress
+// tracking); reads the shared agent roster from state.js for the
+// target-chip pickers. Render + format helpers come from util.js.
+
+import { $, el } from './common.js';
+import { paintAtomic, fmtAgo, fmtDuration } from './util.js';
+import { containersState } from './state.js';
+
+export async function refreshReminders() {
+  const liveRoot = $('reminders-section');
+  if (!liveRoot) return;
+  try {
+    const resp = await fetch('/api/reminders');
+    if (!resp.ok) {
+      paintAtomic(liveRoot, (root) => {
+        root.append(el('p', { class: 'empty' }, 'reminders unavailable: http ' + resp.status));
+      });
+      return;
+    }
+    const rows = await resp.json();
+    renderReminders(rows);
+  } catch (err) {
+    paintAtomic(liveRoot, (root) => {
+      root.append(el('p', { class: 'empty' }, 'reminders fetch failed: ' + err));
+    });
+  }
+}
+function renderReminders(rows) {
+  const liveRoot = $('reminders-section');
+  if (!liveRoot) return;
+  paintAtomic(liveRoot, (root) => {
+    if (!rows.length) {
+      root.append(el('p', { class: 'empty' }, 'no queued reminders'));
+      return;
+    }
+    const ul = el('ul', { class: 'reminders' });
+    for (const r of rows) {
+      const failed = (r.attempt_count || 0) > 0;
+      const li = el('li', { class: 'reminder-row' + (failed ? ' reminder-failed' : '') });
+      const dueIn = r.due_at - Math.floor(Date.now() / 1000);
+      const dueLabel = dueIn <= 0
+        ? `overdue ${fmtAgo(r.due_at)}`
+        : `in ${fmtDuration(dueIn)}`;
+      const head = el('div', { class: 'reminder-head' },
+        el('span', { class: 'agent' }, r.agent), ' ',
+        el('span', {
+          class: 'meta reminder-due',
+          title: new Date(r.due_at * 1000).toISOString(),
+          'data-due-at': String(r.due_at),
+        }, dueLabel),
+        ' ',
+        el('span', { class: 'meta' }, `· id ${r.id}`),
+      );
+      if (r.file_path) {
+        head.append(' ', el('span', { class: 'meta' }, '· payload → '));
+        appendLinkified(head, r.file_path);
+      }
+      if (failed) {
+        head.append(' ', el('span',
+          {
+            class: 'badge badge-warn',
+            title: 'consecutive failed delivery attempts (capped at 5; over the cap the scheduler stops retrying until you click R3TRY or cancel)',
+          },
+          `⚠ ${r.attempt_count} failed`));
+      }
+      const body = el('div', { class: 'reminder-body' });
+      appendLinkified(body, r.message);
+      li.append(head, body);
+      if (r.last_error) {
+        li.append(el('div', { class: 'reminder-error' },
+          el('span', { class: 'msg-sep' }, 'error: '),
+          r.last_error,
+        ));
+      }
+      const actions = el('div', { class: 'reminder-actions' });
+      if (failed) {
+        // Retry resets the failure counters so the scheduler picks
+        // the row up again on its next 5s tick. No data-no-refresh
+        // — the resulting refreshState re-fires refreshReminders.
+        const retryForm = el('form', {
+          method: 'POST', action: '/retry-reminder/' + r.id,
+          class: 'inline', 'data-async': '',
+        });
+        retryForm.append(el('button',
+          { type: 'submit', class: 'btn btn-restart' }, '↻ R3TRY'));
+        actions.append(retryForm);
+      }
+      const cancelForm = el('form', {
+        method: 'POST', action: '/cancel-reminder/' + r.id,
+        class: 'inline', 'data-async': '',
+        'data-confirm': `cancel reminder ${r.id} for ${r.agent}? this drops the queued delivery; no undo.`,
+      });
+      cancelForm.append(el('button', { type: 'submit', class: 'btn btn-deny' }, '✗ C4NC3L'));
+      actions.append(cancelForm);
+      li.append(actions);
+      ul.append(li);
+    }
+    root.append(ul);
+  });
+}
+// ─── scheduled prompts ─────────────────────────────────────────────────
+// Backend exposes `/api/schedules` (snapshot), `/api/schedules`
+// (POST, operator-direct submit), `/api/schedules/{id}/cancel`
+// (whole or per-target), `/api/schedules/{id}` (PATCH edit),
+// `/api/schedules/{id}/fire-now` (POST). Mutations now emit a
+// `schedules_changed` SSE event so the list updates live;
+// `applySchedulesChanged` handles it. Tab-activation re-fetch kept as
+// a safety net for approval-path inserts and disconnect windows.
+// Local cache lets `refreshTabCounts` show the active count without
+// re-fetching every second.
+let schedulesState = [];
+// Schedule ids whose inline edit form is currently open. The set
+// survives across refreshSchedules() calls so a state
+// poll doesn't yank the form out from under the operator. Per-id
+// mid-edit carry sits in `scheduleEditCarry` so unsaved typing
+// also rides the refresh.
+const editingSchedules = new Set();
+const scheduleEditCarry = new Map();
+export async function refreshSchedules() {
+  const listRoot = $('schedules-section');
+  if (!listRoot) return;
+  try {
+    const resp = await fetch('/api/schedules');
+    if (!resp.ok) {
+      paintAtomic(listRoot, (root) => {
+        root.append(el('p', { class: 'empty' }, 'schedules unavailable: http ' + resp.status));
+      });
+      return;
+    }
+    schedulesState = await resp.json();
+  } catch (err) {
+    paintAtomic(listRoot, (root) => {
+      root.append(el('p', { class: 'empty' }, 'schedules fetch failed: ' + err));
+    });
+    return;
+  }
+  renderSchedulesList();
+}
+// Active = at least one target still alive (no `cancelled_at_unix`)
+// AND the whole schedule isn't cancelled. Drives the tab pill count.
+export function activeScheduleCount() {
+  let n = 0;
+  for (const s of schedulesState) {
+    if (s.cancelled_at_unix) continue;
+    if ((s.targets || []).some((t) => !t.cancelled_at_unix)) n++;
+  }
+  return n;
+}
+// Label + caption wrapper shared by every field on the schedule
+// forms — `<label class="schedule-field"><span
+// class="schedule-field-label">…</span>…children…</label>`. Variadic
+// children land inside the label after the caption span, which is
+// what every caller wants (the input + any preset/parts/preview
+// sub-rows live next to the caption).
+function scheduleField(labelText, ...children) {
+  return el('label', { class: 'schedule-field' },
+    el('span', { class: 'schedule-field-label' }, labelText),
+    ...children);
+}
+
+// Interval composer — shared between the new-schedule form and
+// the edit-schedule form. Builds the preset chip row +
+// d/h/m/s sub-fields + live preview, and returns helpers to read
+// and write the value.
+//
+// The composer carries no opinion on what "0 / blank" means at the
+// semantic layer: it just reports the integer total. Callers decide
+// whether to treat 0 as `null` (one-shot) for their own submit path.
+function buildIntervalComposer({
+  label = 'interval (blank / all-zero = one-shot)',
+  namePrefix = 'interval_',
+  initialSeconds = 0,
+} = {}) {
+  const wrapper = scheduleField(label);
+  const presets = [
+    ['1m', 60], ['5m', 300], ['15m', 900], ['30m', 1800],
+    ['1h', 3600], ['6h', 21600], ['12h', 43200],
+    ['1d', 86400], ['7d', 604800],
+  ];
+  const presetsRow = el('div', { class: 'schedule-interval-presets' });
+  for (const [presetLabel, secs] of presets) {
+    presetsRow.append(el('button', {
+      type: 'button',
+      class: 'btn btn-interval-preset',
+      'data-secs': String(secs),
+    }, presetLabel));
+  }
+  presetsRow.append(el('button', {
+    type: 'button',
+    class: 'btn btn-interval-preset btn-interval-oneshot',
+    'data-secs': '0',
+  }, 'one-shot'));
+  wrapper.append(presetsRow);
+
+  const partsRow = el('div', { class: 'schedule-interval-parts' });
+  const mkPart = (suffix, unit) => {
+    const inp = el('input', {
+      type: 'number', name: namePrefix + suffix, min: '0', step: '1', placeholder: '0',
+      class: 'schedule-interval-num',
+    });
+    partsRow.append(inp, el('span', { class: 'schedule-interval-unit' }, unit));
+    return inp;
+  };
+  const dInp = mkPart('d', 'd');
+  const hInp = mkPart('h', 'h');
+  const mInp = mkPart('m', 'm');
+  const sInp = mkPart('s', 's');
+  wrapper.append(partsRow);
+
+  const preview = el('div', { class: 'schedule-interval-preview', 'aria-live': 'polite' });
+  wrapper.append(preview);
+
+  function getSeconds() {
+    const n = (v) => {
+      const x = parseInt(v, 10);
+      return Number.isFinite(x) && x > 0 ? x : 0;
+    };
+    return n(dInp.value) * 86400 + n(hInp.value) * 3600
+      + n(mInp.value) * 60 + n(sInp.value);
+  }
+  function fillFromSeconds(total) {
+    const t = Math.max(0, Math.floor(total));
+    const d = Math.floor(t / 86400);
+    const h = Math.floor((t % 86400) / 3600);
+    const m = Math.floor((t % 3600) / 60);
+    const s = t % 60;
+    dInp.value = d > 0 ? String(d) : '';
+    hInp.value = h > 0 ? String(h) : '';
+    mInp.value = m > 0 ? String(m) : '';
+    sInp.value = s > 0 ? String(s) : '';
+  }
+  function setParts({ d, h, m, s }) {
+    if (d !== undefined) dInp.value = d;
+    if (h !== undefined) hInp.value = h;
+    if (m !== undefined) mInp.value = m;
+    if (s !== undefined) sInp.value = s;
+  }
+  function updatePreview() {
+    const total = getSeconds();
+    preview.textContent = total > 0
+      ? '↻ every ' + fmtDuration(total)
+      : 'one-shot (fires once at first-fire time)';
+    preview.classList.toggle('schedule-interval-preview-oneshot', total === 0);
+  }
+  for (const inp of [dInp, hInp, mInp, sInp]) {
+    inp.addEventListener('input', updatePreview);
+  }
+  for (const b of presetsRow.querySelectorAll('button[data-secs]')) {
+    b.addEventListener('click', () => {
+      fillFromSeconds(parseInt(b.getAttribute('data-secs'), 10) || 0);
+      updatePreview();
+    });
+  }
+  if (initialSeconds > 0) fillFromSeconds(initialSeconds);
+  updatePreview();
+
+  return { wrapper, getSeconds, fillFromSeconds, setParts, updatePreview };
+}
+
+// Parse the d/h/m/s sub-fields of a `buildIntervalComposer` instance
+// out of submitted FormData. Returns total seconds, or NaN if any
+// field carries a non-integer / negative value — the caller alerts
+// and bails. Total `0` means "one-shot" at the call site (wire is
+// `interval_seconds: null`). `namePrefix` matches the prefix passed
+// to `buildIntervalComposer` (e.g. `interval_` or `edit_interval_`).
+function intervalSecondsFromFormData(fd, namePrefix) {
+  const part = (suffix, mult) => {
+    const raw = String(fd.get(namePrefix + suffix) || '').trim();
+    if (!raw) return 0;
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0) return NaN;
+    return n * mult;
+  };
+  return part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
+}
+
+// Targets multi-select chip box — shared between the new-schedule
+// form and the edit-schedule form. Same DOM shape, same candidate
+// list (containers + operator + root); only the chip element id
+// prefix and checkbox field name vary. Used to be inlined twice in
+// near-identical 18-line blocks; consolidated here so a future
+// change (new chip kind, candidate-list source swap, etc.) lives in
+// one place. Returns the wrapping `<label class="schedule-field">`
+// ready to append to the form.
+function buildTargetChips({ idPrefix, fieldName, checked, extraNames = [] }) {
+  const candidates = ['operator'];
+  const containerNames = Array.from(containersState.values())
+    .map((c) => c.name)
+    .filter((n) => n !== 'operator')
+    .sort();
+  for (const n of containerNames) candidates.push(n);
+  // `extraNames` lets the edit form keep showing an already-active
+  // target that's vanished from the live container list (operator's
+  // typo, container destroyed mid-schedule, etc.) so it's still
+  // explicitly uncheckable. New-schedule callers pass `[]`.
+  for (const n of extraNames) if (!candidates.includes(n)) candidates.push(n);
+
+  const box = el('div', { class: 'schedule-targets' });
+  for (const name of candidates) {
+    const id_ = idPrefix + name;
+    const cb = el('input', {
+      type: 'checkbox', name: fieldName, value: name, id: id_,
+    });
+    if (checked.has(name)) cb.checked = true;
+    box.append(el('label', { class: 'schedule-target-chip', for: id_ },
+      cb, el('span', {}, name)));
+  }
+  return scheduleField('targets', box);
+}
+
+// Inline-create carry-state — survives paintAtomic re-renders.
+// The schedules table refreshes on tab activate + after every mutation,
+// and each refresh rebuilds the DOM via `paintAtomic`. The bottom
+// create row's inputs would lose mid-typing values without this
+// carry. `readNewScheduleCarryFromDOM` is called BEFORE every
+// re-render so the carry sees the latest user input; the row
+// builders then pre-fill from `newScheduleCarry`.
+const newScheduleCarry = {
+  targets: new Set(),
+  body: '',
+  description: '',
+  first_fire: '',
+  interval_d: '',
+  interval_h: '',
+  interval_m: '',
+  interval_s: '',
+};
+function readNewScheduleCarryFromDOM(tr) {
+  if (!tr) return;
+  const get = (sel) => tr.querySelector(sel);
+  const checked = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
+    .map((i) => i.value);
+  newScheduleCarry.targets = new Set(checked);
+  const setIfDefined = (key, sel) => {
+    const el_ = get(sel);
+    if (el_) newScheduleCarry[key] = el_.value || '';
+  };
+  setIfDefined('body', 'textarea[name="new_body"]');
+  setIfDefined('description', 'input[name="new_description"]');
+  setIfDefined('first_fire', 'input[name="new_first_fire"]');
+  setIfDefined('interval_d', 'input[name="new_interval_d"]');
+  setIfDefined('interval_h', 'input[name="new_interval_h"]');
+  setIfDefined('interval_m', 'input[name="new_interval_m"]');
+  setIfDefined('interval_s', 'input[name="new_interval_s"]');
+}
+function resetNewScheduleCarry() {
+  newScheduleCarry.targets = new Set();
+  newScheduleCarry.body = '';
+  newScheduleCarry.description = '';
+  newScheduleCarry.first_fire = '';
+  newScheduleCarry.interval_d = '';
+  newScheduleCarry.interval_h = '';
+  newScheduleCarry.interval_m = '';
+  newScheduleCarry.interval_s = '';
+}
+function isoForDatetimeLocal(date) {
+  // `<input type="datetime-local">` expects `YYYY-MM-DDTHH:MM`
+  // in the user's local timezone (with no trailing Z). Build it
+  // by hand rather than slicing toISOString which is always UTC.
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
+    + `T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+// Schedules render as a single table — one row per schedule,
+// attribute columns + one ✓/✕ column per agent (tilted 45° header
+// so a row of agents takes ~28px each instead of full word width),
+// actions column on the right. Edit form expands into a colspan'd
+// row underneath when its row's `✎` is toggled on.
+function renderSchedulesList() {
+  const liveRoot = $('schedules-section');
+  if (!liveRoot) return;
+  // Capture any mid-typed inline-create state BEFORE paintAtomic
+  // blows the row away so a refresh doesn't yank the operator's
+  // half-filled form. The carry is replayed by
+  // `renderInlineCreateRow` below.
+  readNewScheduleCarryFromDOM(liveRoot.querySelector('.schedules-table-create-row'));
+  paintAtomic(liveRoot, (root) => {
+    const agents = schedulesTableAgentSet();
+    const table = el('table', { class: 'schedules-table' });
+    table.append(renderSchedulesTableHead(agents));
+    const tbody = el('tbody', {});
+    const sorted = schedulesState.slice().sort((a, b) => {
+      const aDone = a.cancelled_at_unix ? 1 : 0;
+      const bDone = b.cancelled_at_unix ? 1 : 0;
+      if (aDone !== bDone) return aDone - bDone;
+      return a.next_fire_at_unix - b.next_fire_at_unix;
+    });
+    for (const s of sorted) {
+      tbody.append(renderScheduleRow(s, agents));
+      if (editingSchedules.has(s.id) && !s.cancelled_at_unix) {
+        tbody.append(renderScheduleEditRow(s, agents));
+      }
+    }
+    // Always-visible inline create row at the bottom of the table
+    // — fill cells + click ＋ to POST. See
+    // docs/web-ui.md::SCH3DUL3S tab for the layout rationale.
+    tbody.append(renderInlineCreateRow(agents));
+    table.append(tbody);
+    const wrap = el('div', { class: 'schedules-table-wrap' });
+    wrap.append(table);
+    root.append(wrap);
+  });
+}
+// Inline create row. Each column carries an input matching its
+// display semantics (datetime-local for next-fire, mini d/h/m/s
+// number inputs for every, textarea for body, checkbox per agent
+// column for targets). Submitting POSTs `/api/schedules` and clears
+// the carry on success; the next `refreshSchedules` redraws the
+// table with the new schedule above.
+function renderInlineCreateRow(agents) {
+  const tr = el('tr', { class: 'schedules-table-create-row' });
+
+  tr.append(el('td', { class: 'meta schedules-table-id' }, 'new'));
+  tr.append(el('td', { class: 'meta' }, '—'));
+
+  const nextInput = el('input', {
+    type: 'datetime-local',
+    name: 'new_first_fire',
+    class: 'schedules-table-inline-input schedules-table-inline-datetime',
+    required: 'required',
+    title: 'first fire time (defaults to 5 minutes from now)',
+  });
+  // Default: 5 minutes from now so a stale-clock or quick-submit
+  // accident doesn't fire immediately on `now()`.
+  nextInput.value = newScheduleCarry.first_fire
+    || isoForDatetimeLocal(new Date(Date.now() + 5 * 60 * 1000));
+  tr.append(el('td', { class: 'schedules-table-create-cell' }, nextInput));
+
+  const intervalRow = el('div', {
+    class: 'schedules-table-inline-interval',
+    title: 'recurring every D days H hours M minutes S seconds (all blank / zero = one-shot)',
+  });
+  const mkUnit = (suffix, unit) => {
+    const inp = el('input', {
+      type: 'number',
+      name: 'new_interval_' + suffix,
+      min: '0',
+      step: '1',
+      placeholder: '0',
+      class: 'schedules-table-inline-num',
+      'aria-label': 'interval ' + suffix,
+    });
+    inp.value = newScheduleCarry['interval_' + suffix] || '';
+    intervalRow.append(inp, el('span', { class: 'schedules-table-inline-unit' }, unit));
+  };
+  mkUnit('d', 'd');
+  mkUnit('h', 'h');
+  mkUnit('m', 'm');
+  mkUnit('s', 's');
+  tr.append(el('td', { class: 'schedules-table-create-cell' }, intervalRow));
+
+  tr.append(el('td', { class: 'meta' }, 'operator'));
+
+  const bodyTa = el('textarea', {
+    name: 'new_body',
+    rows: '1',
+    required: 'required',
+    placeholder: 'prompt body (required, multi-line ok)',
+    class: 'schedules-table-inline-textarea',
+  });
+  bodyTa.value = newScheduleCarry.body;
+  const descInput = el('input', {
+    type: 'text',
+    name: 'new_description',
+    placeholder: 'description (optional)',
+    class: 'schedules-table-inline-input schedules-table-inline-desc',
+  });
+  descInput.value = newScheduleCarry.description;
+  tr.append(el('td', { class: 'schedules-table-create-cell schedules-table-create-body' },
+    bodyTa, descInput));
+
+  // Per-agent target checkboxes — one cell per agent column. Wrap
+  // each checkbox in a label so the whole cell area is clickable.
+  for (const a of agents) {
+    const td = el('td', { class: 'schedules-table-check schedules-table-create-cell' });
+    const id_ = 'new-target-' + a;
+    const cb = el('input', {
+      type: 'checkbox',
+      name: 'new_targets',
+      value: a,
+      id: id_,
+      class: 'schedules-table-inline-check',
+    });
+    if (newScheduleCarry.targets.has(a)) cb.checked = true;
+    const lbl = el('label', {
+      for: id_,
+      class: 'schedules-table-inline-check-lbl',
+      title: 'tick to target ' + a,
+    }, cb);
+    td.append(lbl);
+    tr.append(td);
+  }
+
+  // Actions cell — submit button + reset.
+  const actionsCell = el('td', { class: 'schedules-table-actions' });
+  const submitBtn = el('button', {
+    type: 'button',
+    class: 'btn btn-spawn btn-inline-small schedules-table-create-submit',
+    title: 'queue this new schedule',
+  }, '＋');
+  submitBtn.addEventListener('click', () => submitNewScheduleInline(tr, submitBtn));
+  const resetBtn = el('button', {
+    type: 'button',
+    class: 'btn btn-inline-small schedules-table-create-reset',
+    title: 'clear all fields',
+  }, '⌫');
+  resetBtn.addEventListener('click', () => {
+    resetNewScheduleCarry();
+    renderSchedulesList();
+  });
+  actionsCell.append(submitBtn, resetBtn);
+  tr.append(actionsCell);
+
+  return tr;
+}
+async function submitNewScheduleInline(tr, submitBtn) {
+  const targets = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
+    .map((i) => i.value);
+  const body = String(tr.querySelector('textarea[name="new_body"]')?.value || '').trim();
+  const description = String(tr.querySelector('input[name="new_description"]')?.value || '').trim();
+  const firstFireStr = String(tr.querySelector('input[name="new_first_fire"]')?.value || '');
+
+  if (!targets.length) {
+    alert('schedule must have at least one target — tick at least one agent column');
+    return;
+  }
+  if (!body) { alert('prompt body must be non-empty'); return; }
+  if (!firstFireStr) { alert('first fire timestamp is required'); return; }
+  const firstFireDate = new Date(firstFireStr);
+  if (Number.isNaN(firstFireDate.getTime())) {
+    alert('first fire is not a valid datetime'); return;
+  }
+  const first_fire_at_unix = Math.floor(firstFireDate.getTime() / 1000);
+
+  // Parse the d/h/m/s parts inline — we don't use FormData since
+  // the inline row isn't wrapped in a <form>. Mirrors
+  // `intervalSecondsFromFormData` semantics: blank/0 = one-shot,
+  // anything non-integer or negative → NaN → alert.
+  const part = (suffix, mult) => {
+    const raw = String(tr.querySelector(`input[name="new_interval_${suffix}"]`)?.value || '').trim();
+    if (!raw) return 0;
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0) return NaN;
+    return n * mult;
+  };
+  const intervalTotal = part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
+  if (Number.isNaN(intervalTotal)) {
+    alert('interval fields must be non-negative integers (or blank for one-shot)');
+    return;
+  }
+  const interval_seconds = intervalTotal > 0 ? intervalTotal : null;
+
+  const payload = { targets, body, first_fire_at_unix };
+  if (interval_seconds != null) payload.interval_seconds = interval_seconds;
+  if (description) payload.description = description;
+
+  const originalLabel = submitBtn.innerHTML;
+  submitBtn.disabled = true;
+  submitBtn.innerHTML = '<span class="spinner">◐</span>';
+  try {
+    const resp = await fetch('/api/schedules', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      alert('schedule submit failed: http ' + resp.status + (text ? '\n\n' + text : ''));
+      return;
+    }
+    // Reset carry so the next render shows an empty row.
+    resetNewScheduleCarry();
+    await refreshSchedules();
+  } catch (err) {
+    alert('schedule submit failed: ' + err);
+  } finally {
+    submitBtn.disabled = false;
+    submitBtn.innerHTML = originalLabel;
+  }
+}
+// The set of agent columns in the schedules table: operator + root
+// (manager) first, then live containers (sorted), then any extra names
+// that appear as a schedule target but aren't in the live container list
+// (operator typo, container destroyed mid-schedule, etc.) — same
+// membership rule as `buildTargetChips` so the table and the new-/
+// edit-form chip boxes agree on what's addressable.
+function schedulesTableAgentSet() {
+  const seen = new Set();
+  const out = [];
+  const push = (n) => { if (!seen.has(n)) { seen.add(n); out.push(n); } };
+  push('operator');
+  const containerNames = Array.from(containersState.values())
+    .map((c) => c.name)
+    .filter((n) => n !== 'operator')
+    .sort();
+  for (const n of containerNames) push(n);
+  for (const s of schedulesState) {
+    for (const t of s.targets || []) push(t.target);
+  }
+  return out;
+}
+function renderSchedulesTableHead(agents) {
+  const thead = el('thead', {});
+  const headerRow = el('tr', {});
+  headerRow.append(
+    el('th', { class: 'schedules-table-id' }, '#'),
+    el('th', {}, 'src'),
+    el('th', { class: 'schedules-table-next-col' }, 'next'),
+    el('th', { class: 'schedules-table-every-col' }, 'every'),
+    el('th', {}, 'owner'),
+    el('th', { class: 'schedules-table-body-th' }, 'body'),
+  );
+  for (const a of agents) {
+    headerRow.append(el('th', { class: 'schedules-table-agent-th', title: a },
+      el('div', {}, el('span', {}, a))));
+  }
+  headerRow.append(el('th', { class: 'schedules-table-actions-th' }, ''));
+  thead.append(headerRow);
+  return thead;
+}
+function renderScheduleRow(s, agents) {
+  const cancelled = !!s.cancelled_at_unix;
+  const tr = el('tr', {
+    class: 'schedules-table-row' + (cancelled ? ' schedules-table-row-cancelled' : ''),
+  });
+
+  tr.append(el('td', { class: 'meta schedules-table-id' }, '#' + s.id));
+
+  const srcKind = s.source && s.source.kind === 'approval' ? 'approval' : 'manual';
+  tr.append(el('td', {},
+    el('span', { class: 'rqe-source rqe-source-' + srcKind },
+      srcKind === 'approval' ? 'approval' : 'operator')));
+
+  // "next" cell — relative due-in for active schedules, "cancelled"
+  // for cancelled ones. Both carry the absolute ISO in the title.
+  const nextCell = el('td', { class: 'meta schedules-table-next-col' });
+  if (cancelled) {
+    nextCell.title = 'cancelled ' + new Date(s.cancelled_at_unix * 1000).toISOString();
+    nextCell.textContent = 'cancelled';
+  } else {
+    const dueIn = s.next_fire_at_unix - Math.floor(Date.now() / 1000);
+    nextCell.title = new Date(s.next_fire_at_unix * 1000).toISOString();
+    nextCell.textContent = dueIn <= 0
+      ? 'overdue ' + fmtAgo(s.next_fire_at_unix)
+      : fmtDuration(dueIn);
+    nextCell.classList.add('sched-due');
+    nextCell.dataset.dueAt = String(s.next_fire_at_unix);
+  }
+  tr.append(nextCell);
+
+  tr.append(el('td', { class: 'meta schedules-table-every-col' },
+    s.interval_seconds ? '↻ ' + fmtDuration(s.interval_seconds) : 'one-shot'));
+
+  tr.append(el('td', { class: 'meta' }, s.owner));
+
+  // Body cell — truncates with ellipsis; full body + description (if
+  // any) on hover. Description used to be a separate visible block on
+  // the card layout; the table compresses it into the title to keep
+  // row height tight. Mara nit-flag candidate if she actually wants
+  // it visible in-table.
+  const bodyCell = el('td', { class: 'schedules-table-body-cell' });
+  const bodyText = s.body || '';
+  bodyCell.title = (s.description ? s.description + '\n\n' : '') + bodyText;
+  bodyCell.textContent = bodyText;
+  tr.append(bodyCell);
+
+  // Per-agent target cells. Three states:
+  //   - active target → ✓ button that cancels just that target on
+  //     click (same affordance as the per-row ✕ on the old layout's
+  //     targets table)
+  //   - cancelled target → muted ✕ glyph (no button — backend
+  //     re-add flows through the edit form's targets multi-select)
+  //   - not a target → empty cell
+  const targetByName = new Map();
+  for (const t of s.targets || []) targetByName.set(t.target, t);
+  for (const a of agents) {
+    const t = targetByName.get(a);
+    const td = el('td', { class: 'schedules-table-check' });
+    if (!t) {
+      // empty — no button, no glyph
+    } else if (t.cancelled_at_unix) {
+      td.title = 'cancelled — '
+        + (t.last_fired_at_unix
+          ? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
+          : 'never fired')
+        + (t.last_result ? ' · ' + t.last_result : '');
+      td.append(el('span', { class: 'schedules-table-check-cancelled' }, '✕'));
+    } else {
+      const lastFireDesc = t.last_fired_at_unix
+        ? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
+        : 'never fired';
+      const lastResultDesc = t.last_result ? ' · ' + t.last_result : '';
+      const checkBtn = el('button', {
+        type: 'button',
+        class: 'schedules-table-check-btn',
+      }, '✓');
+      checkBtn.title = lastFireDesc + lastResultDesc
+        + (cancelled ? '' : '\nclick to cancel this target');
+      if (cancelled) {
+        checkBtn.disabled = true;
+      } else {
+        checkBtn.addEventListener('click', () => cancelScheduleTargets(s.id, [a]));
+      }
+      td.append(checkBtn);
+    }
+    tr.append(td);
+  }
+
+  // Actions cell — fire / edit / cancel-all. Glyph-only to fit a
+  // compact column; the buttons keep their existing colour classes
+  // so the visual cue (mauve = fire, yellow = edit, red = cancel)
+  // carries over from the card layout.
+  const actionsCell = el('td', { class: 'schedules-table-actions' });
+  if (!cancelled) {
+    const activeTargets = (s.targets || []).filter((t) => !t.cancelled_at_unix);
+    const isOneShot = !s.interval_seconds;
+    const fireBtn = el('button', {
+      type: 'button',
+      class: 'btn btn-fire-now btn-inline-small',
+    }, '↯');
+    fireBtn.title = isOneShot
+      ? 'fire once — one-shot, consumed after the manual fire'
+      : 'fire once now — recurring, next regular fire unaffected';
+    if (!activeTargets.length) {
+      fireBtn.disabled = true;
+      fireBtn.title = 'every target is cancelled — nothing to fire';
+    }
+    fireBtn.addEventListener('click', () =>
+      fireScheduleNow(s.id, isOneShot, activeTargets.map((t) => t.target), fireBtn));
+    actionsCell.append(fireBtn);
+
+    const editingThis = editingSchedules.has(s.id);
+    const editBtn = el('button', {
+      type: 'button',
+      class: 'btn btn-edit-schedule btn-inline-small',
+    }, editingThis ? '✎×' : '✎');
+    editBtn.title = editingThis
+      ? 'close edit'
+      : 'edit body / description / interval / next-fire / targets';
+    editBtn.addEventListener('click', () => {
+      if (editingThis) {
+        editingSchedules.delete(s.id);
+        scheduleEditCarry.delete(s.id);
+      } else {
+        editingSchedules.add(s.id);
+      }
+      renderSchedulesList();
+    });
+    actionsCell.append(editBtn);
+
+    const cancelBtn = el('button', {
+      type: 'button',
+      class: 'btn btn-deny btn-inline-small',
+    }, '✕');
+    cancelBtn.title = 'cancel the whole schedule';
+    cancelBtn.addEventListener('click', () => cancelScheduleAll(s.id));
+    actionsCell.append(cancelBtn);
+  }
+  tr.append(actionsCell);
+
+  return tr;
+}
+function renderScheduleEditRow(s, agents) {
+  // colspan = 6 attribute cols + N agent cols + 1 actions col
+  const colCount = 7 + agents.length;
+  const tr = el('tr', { class: 'schedules-table-edit-row' });
+  const td = el('td', { colspan: String(colCount) });
+  td.append(renderScheduleEditForm(s));
+  tr.append(td);
+  return tr;
+}
+
+// Inline edit form. Renders inside the schedule row when the
+// row's `✎ edit` button is toggled on. Pre-filled with current
+// values; submit PATCHes /api/schedules/{id}. Targets stay
+// immutable (per damocles's backend; the workaround for retargeting
+// is cancel + new schedule). Mid-edit field values survive a
+// state-poll refresh via `scheduleEditCarry`.
+function renderScheduleEditForm(s) {
+  const wrapper = el('div', { class: 'schedule-edit-form-wrapper' });
+  const form_ = el('form', { class: 'schedule-edit-form' });
+  form_.addEventListener('submit', (e) => {
+    e.preventDefault();
+    submitEditSchedule(s, form_);
+  });
+
+  const carry = scheduleEditCarry.get(s.id) || {};
+
+  const bodyInput = el('textarea', { name: 'body', rows: '4', required: 'required' });
+  bodyInput.value = carry.body !== undefined ? carry.body : s.body;
+  form_.append(scheduleField('body', bodyInput));
+
+  const descInput = el('input', { type: 'text', name: 'description' });
+  descInput.value = carry.description !== undefined
+    ? carry.description
+    : (s.description || '');
+  form_.append(scheduleField('description (blank to clear)', descInput));
+
+  const firstFireInput = el('input', {
+    type: 'datetime-local', name: 'next_fire', required: 'required',
+  });
+  firstFireInput.value = carry.next_fire !== undefined
+    ? carry.next_fire
+    : isoForDatetimeLocal(new Date(s.next_fire_at_unix * 1000));
+  form_.append(scheduleField('next fire', firstFireInput));
+
+  const intervalCx = buildIntervalComposer({
+    label: 'interval (blank / all-zero = flip to one-shot)',
+    namePrefix: 'edit_interval_',
+    initialSeconds: 0,
+  });
+  form_.append(intervalCx.wrapper);
+  if (carry.interval_d !== undefined || carry.interval_h !== undefined
+      || carry.interval_m !== undefined || carry.interval_s !== undefined) {
+    intervalCx.setParts({
+      d: carry.interval_d || '',
+      h: carry.interval_h || '',
+      m: carry.interval_m || '',
+      s: carry.interval_s || '',
+    });
+  } else if (s.interval_seconds) {
+    intervalCx.fillFromSeconds(s.interval_seconds);
+  }
+  intervalCx.updatePreview();
+
+  // Persist carry on every input + checkbox change so a refresh
+  // repaint preserves it.
+  const saveCarry = () => {
+    const fd = new FormData(form_);
+    scheduleEditCarry.set(s.id, {
+      body: String(fd.get('body') || ''),
+      description: String(fd.get('description') || ''),
+      next_fire: String(fd.get('next_fire') || ''),
+      interval_d: String(fd.get('edit_interval_d') || ''),
+      interval_h: String(fd.get('edit_interval_h') || ''),
+      interval_m: String(fd.get('edit_interval_m') || ''),
+      interval_s: String(fd.get('edit_interval_s') || ''),
+      targets: fd.getAll('edit_targets').map(String),
+    });
+  };
+  form_.addEventListener('input', saveCarry);
+  form_.addEventListener('change', saveCarry);
+
+  // Targets multi-select. Shares the chip-box pattern with the
+  // new-schedule form via `buildTargetChips`;
+  // cancelled tombstones aren't listed (re-adding them flows
+  // through `targets_add`, which the backend replace-on-conflict
+  // drops the tombstone for). Submit diffs against the original
+  // active set to populate `targets_add` / `targets_remove` on the
+  // PATCH body.
+  const originalActiveTargets = new Set(
+    (s.targets || []).filter((t) => !t.cancelled_at_unix).map((t) => t.target),
+  );
+  form_.append(buildTargetChips({
+    idPrefix: 'se-' + s.id + '-',
+    fieldName: 'edit_targets',
+    checked: carry.targets ? new Set(carry.targets) : originalActiveTargets,
+    extraNames: [...originalActiveTargets],
+  }));
+  form_.append(el('p', { class: 'meta schedule-edit-targets-note' },
+    're-adding a previously cancelled target drops its history and starts fresh; '
+    + 'unchecking an active target cancels it.'));
+
+  const actions = el('div', { class: 'schedule-actions' });
+  const submit = el('button', { type: 'submit', class: 'btn btn-spawn' }, '✓ save changes');
+  const cancelEdit = el('button', { type: 'button', class: 'btn' }, 'cancel');
+  cancelEdit.addEventListener('click', () => {
+    editingSchedules.delete(s.id);
+    scheduleEditCarry.delete(s.id);
+    renderSchedulesList();
+  });
+  actions.append(submit, cancelEdit);
+  form_.append(actions);
+
+  wrapper.append(form_);
+  return wrapper;
+}
+
+async function submitEditSchedule(originalSchedule, form_) {
+  const s = originalSchedule;
+  const fd = new FormData(form_);
+  const newBody = String(fd.get('body') || '').trim();
+  const newDescription = String(fd.get('description') || '').trim();
+  const newNextFireStr = String(fd.get('next_fire') || '');
+
+  if (!newBody) { alert('body must be non-empty'); return; }
+  if (!newNextFireStr) { alert('next-fire timestamp is required'); return; }
+  const newNextFireDate = new Date(newNextFireStr);
+  if (Number.isNaN(newNextFireDate.getTime())) {
+    alert('next-fire is not a valid datetime'); return;
+  }
+  const newNextFireUnix = Math.floor(newNextFireDate.getTime() / 1000);
+
+  // Compute interval total from the d/h/m/s fields (composer uses
+  // `edit_interval_*` names in this form).
+  const intervalTotal = intervalSecondsFromFormData(fd, 'edit_interval_');
+  if (Number.isNaN(intervalTotal)) {
+    alert('interval fields must be non-negative integers');
+    return;
+  }
+  const newIntervalSeconds = intervalTotal > 0 ? intervalTotal : null;
+
+  // Compute target diff against the schedule's currently-active set
+  // (cancelled tombstones don't count). The backend treats
+  // `targets_add` as replace-on-conflict (re-adding a tombstoned
+  // target drops its history), so we can just blanket "send the
+  // checked list as add, send the unchecked-but-was-active list as
+  // remove."
+  const newTargets = new Set(fd.getAll('edit_targets').map(String));
+  const originalActive = new Set(
+    (s.targets || [])
+      .filter((t) => !t.cancelled_at_unix)
+      .map((t) => t.target),
+  );
+  if (!newTargets.size) {
+    alert('schedule must have at least one target — uncheck submit, or use ✕ cancel all instead');
+    return;
+  }
+  const targetsAdd = [...newTargets].filter((t) => !originalActive.has(t));
+  const targetsRemove = [...originalActive].filter((t) => !newTargets.has(t));
+
+  // Build the PATCH body. Only include keys for fields that
+  // actually changed; explicit `null` clears description / flips
+  // recurring→one-shot. `targets_add` / `targets_remove` only
+  // populated when non-empty so the wire body stays minimal.
+  const patch = {};
+  if (newBody !== s.body) patch.body = newBody;
+  if (newDescription !== (s.description || '')) {
+    patch.description = newDescription || null;
+  }
+  if (newNextFireUnix !== s.next_fire_at_unix) {
+    patch.next_fire_at_unix = newNextFireUnix;
+  }
+  if (newIntervalSeconds !== (s.interval_seconds || null)) {
+    patch.interval_seconds = newIntervalSeconds;
+  }
+  if (targetsAdd.length) patch.targets_add = targetsAdd;
+  if (targetsRemove.length) patch.targets_remove = targetsRemove;
+  if (!Object.keys(patch).length) {
+    // No-op submit. Treat as "close edit form".
+    editingSchedules.delete(s.id);
+    scheduleEditCarry.delete(s.id);
+    renderSchedulesList();
+    return;
+  }
+
+  const submitBtn = form_.querySelector('button[type="submit"]');
+  const originalLabel = submitBtn ? submitBtn.textContent : '';
+  if (submitBtn) { submitBtn.disabled = true; submitBtn.textContent = 'saving…'; }
+  try {
+    const resp = await fetch('/api/schedules/' + encodeURIComponent(s.id), {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(patch),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      alert('edit failed: http ' + resp.status + (text ? '\n\n' + text : ''));
+      return;
+    }
+    editingSchedules.delete(s.id);
+    scheduleEditCarry.delete(s.id);
+    await refreshSchedules();
+  } catch (err) {
+    alert('edit failed: ' + err);
+  } finally {
+    if (submitBtn) { submitBtn.disabled = false; submitBtn.textContent = originalLabel; }
+  }
+}
+async function fireScheduleNow(id, isOneShot, targets, btn) {
+  const targetList = targets.length ? targets.join(', ') : '(no active targets)';
+  const prompt = isOneShot
+    ? `fire schedule #${id} now to ${targetList}?\n\n`
+      + 'this is a ONE-SHOT — firing now consumes the schedule. '
+      + 'the scheduled fire time will no longer trigger.'
+    : `fire schedule #${id} now to ${targetList}?\n\n`
+      + 'this is RECURRING — sends an extra pulse out-of-band. '
+      + 'the regular cadence keeps firing on schedule.';
+  if (!confirm(prompt)) return;
+  // Capture child nodes so we can restore on error, then replace
+  // with DOM-built content (textContent + element children rather
+  // than innerHTML — the format string only carries server-side
+  // ints/bool today but textContent is the safer pattern if a
+  // stringy field ever lands).
+  const originalChildren = btn ? Array.from(btn.childNodes) : [];
+  const restoreBtn = () => {
+    if (!btn) return;
+    btn.disabled = false;
+    while (btn.firstChild) btn.removeChild(btn.firstChild);
+    for (const n of originalChildren) btn.appendChild(n);
+  };
+  if (btn) {
+    btn.disabled = true;
+    while (btn.firstChild) btn.removeChild(btn.firstChild);
+    btn.append(el('span', { class: 'spinner' }, '◐'), ' firing…');
+  }
+  try {
+    const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/fire-now', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      alert('fire-now failed: http ' + resp.status + (text ? '\n\n' + text : ''));
+      restoreBtn();
+      return;
+    }
+    // Backend returns FireNowReport { ok, failed, missing, one_shot_consumed }.
+    // Flash the per-target outcome on the button itself so the operator
+    // sees the result immediately, then refresh to pick up the
+    // authoritative per-target `last_result` annotations.
+    let report = null;
+    try { report = await resp.json(); } catch { /* shape drift / empty body — ignore */ }
+    if (btn && report) {
+      const bits = [];
+      if (report.ok) bits.push(report.ok + ' ok');
+      if (report.failed) bits.push(report.failed + ' failed');
+      if (report.missing) bits.push(report.missing + ' missing');
+      const suffix = report.one_shot_consumed ? ' — consumed' : '';
+      while (btn.firstChild) btn.removeChild(btn.firstChild);
+      btn.textContent = '↯ fired: ' + (bits.join(', ') || 'no targets') + suffix;
+      btn.classList.add('btn-fire-now-flashed');
+    }
+    // Hold the flash briefly so the operator can read it before the
+    // refresh wipes the row in place.
+    setTimeout(refreshSchedules, 1500);
+  } catch (err) {
+    alert('fire-now failed: ' + err);
+    restoreBtn();
+  }
+}
+async function cancelScheduleAll(id) {
+  if (!confirm(`cancel schedule #${id}? this stops all future fires for every target.`)) return;
+  await postScheduleCancel(id, null);
+}
+async function cancelScheduleTargets(id, targets) {
+  if (!confirm(`cancel schedule #${id} for ${targets.join(', ')}? other targets keep firing.`)) return;
+  await postScheduleCancel(id, targets);
+}
+async function postScheduleCancel(id, targets) {
+  try {
+    const opts = {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    };
+    if (targets) opts.body = JSON.stringify({ targets });
+    const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/cancel', opts);
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      alert('cancel failed: http ' + resp.status + (text ? '\n\n' + text : ''));
+      return;
+    }
+    await refreshSchedules();
+  } catch (err) {
+    alert('cancel failed: ' + err);
+  }
+}
+
+export function applySchedulesChanged(ev) {
+  schedulesState = (ev.schedules || []).slice();
+  renderSchedulesList();
+}
+export function applyRemindersChanged(ev) {
+  renderReminders(ev.reminders || []);
+}
diff --git a/frontend/packages/dashboard/src/tabs.js b/frontend/packages/dashboard/src/tabs.js
index 7345755b..904a7e57 100644
--- a/frontend/packages/dashboard/src/tabs.js
+++ b/frontend/packages/dashboard/src/tabs.js
@@ -20,11 +20,15 @@ import {
 } from './common.js';
 import { createTabStrip } from '@hive/shared/tabs.js';
 import { containersState, syncContainersFromSnapshot } from './state.js';
-import { paintAtomic, fmtAgo, truncate, fmtElapsed, fmtDuration } from './util.js';
+import { fmtAgo, truncate, fmtElapsed, fmtDuration } from './util.js';
 import {
   applyCapabilitiesChanged, applyToolGroupsChanged,
   fetchAndRenderCapabilities, fetchAndRenderToolGroups,
 } from './permissions.js';
+import {
+  applySchedulesChanged, applyRemindersChanged,
+  refreshSchedules, refreshReminders, activeScheduleCount,
+} from './schedules.js';
 
 // mdNode (in common.js) reads `window.marked` for the markdown side
 // panel preview path. Set it here on the dashboard entry so file
@@ -220,13 +224,6 @@ window.marked = marked;
     // See docs/web-ui.md::Container row for the badge taxonomy.
     renderContainersFromState();
   }
-  function applySchedulesChanged(ev) {
-    schedulesState = (ev.schedules || []).slice();
-    renderSchedulesList();
-  }
-  function applyRemindersChanged(ev) {
-    renderReminders(ev.reminders || []);
-  }
   // Map from agent name → highest-priority in-flight queue entry
   // (`running` beats `queued`). Used by the container row renderer
   // to surface "building..." / "meta-updating..." badges on the
@@ -2477,1062 +2474,6 @@ window.marked = marked;
     }
   }, 30_000);
 
-  // ─── reminders ──────────────────────────────────────────────────────────
-  // Reminders aren't part of /api/state (separate sqlite table, separate
-  // mutation cadence). refreshReminders() is called from refreshState() for
-  // cold-load and reconnect recovery. Live mutations are covered by the
-  // `reminders_changed` SSE event → `applyRemindersChanged` so no periodic
-  // poll is needed.
-  async function refreshReminders() {
-    const liveRoot = $('reminders-section');
-    if (!liveRoot) return;
-    try {
-      const resp = await fetch('/api/reminders');
-      if (!resp.ok) {
-        paintAtomic(liveRoot, (root) => {
-          root.append(el('p', { class: 'empty' }, 'reminders unavailable: http ' + resp.status));
-        });
-        return;
-      }
-      const rows = await resp.json();
-      renderReminders(rows);
-    } catch (err) {
-      paintAtomic(liveRoot, (root) => {
-        root.append(el('p', { class: 'empty' }, 'reminders fetch failed: ' + err));
-      });
-    }
-  }
-  function renderReminders(rows) {
-    const liveRoot = $('reminders-section');
-    if (!liveRoot) return;
-    paintAtomic(liveRoot, (root) => {
-      if (!rows.length) {
-        root.append(el('p', { class: 'empty' }, 'no queued reminders'));
-        return;
-      }
-      const ul = el('ul', { class: 'reminders' });
-      for (const r of rows) {
-        const failed = (r.attempt_count || 0) > 0;
-        const li = el('li', { class: 'reminder-row' + (failed ? ' reminder-failed' : '') });
-        const dueIn = r.due_at - Math.floor(Date.now() / 1000);
-        const dueLabel = dueIn <= 0
-          ? `overdue ${fmtAgo(r.due_at)}`
-          : `in ${fmtDuration(dueIn)}`;
-        const head = el('div', { class: 'reminder-head' },
-          el('span', { class: 'agent' }, r.agent), ' ',
-          el('span', {
-            class: 'meta reminder-due',
-            title: new Date(r.due_at * 1000).toISOString(),
-            'data-due-at': String(r.due_at),
-          }, dueLabel),
-          ' ',
-          el('span', { class: 'meta' }, `· id ${r.id}`),
-        );
-        if (r.file_path) {
-          head.append(' ', el('span', { class: 'meta' }, '· payload → '));
-          appendLinkified(head, r.file_path);
-        }
-        if (failed) {
-          head.append(' ', el('span',
-            {
-              class: 'badge badge-warn',
-              title: 'consecutive failed delivery attempts (capped at 5; over the cap the scheduler stops retrying until you click R3TRY or cancel)',
-            },
-            `⚠ ${r.attempt_count} failed`));
-        }
-        const body = el('div', { class: 'reminder-body' });
-        appendLinkified(body, r.message);
-        li.append(head, body);
-        if (r.last_error) {
-          li.append(el('div', { class: 'reminder-error' },
-            el('span', { class: 'msg-sep' }, 'error: '),
-            r.last_error,
-          ));
-        }
-        const actions = el('div', { class: 'reminder-actions' });
-        if (failed) {
-          // Retry resets the failure counters so the scheduler picks
-          // the row up again on its next 5s tick. No data-no-refresh
-          // — the resulting refreshState re-fires refreshReminders.
-          const retryForm = el('form', {
-            method: 'POST', action: '/retry-reminder/' + r.id,
-            class: 'inline', 'data-async': '',
-          });
-          retryForm.append(el('button',
-            { type: 'submit', class: 'btn btn-restart' }, '↻ R3TRY'));
-          actions.append(retryForm);
-        }
-        const cancelForm = el('form', {
-          method: 'POST', action: '/cancel-reminder/' + r.id,
-          class: 'inline', 'data-async': '',
-          'data-confirm': `cancel reminder ${r.id} for ${r.agent}? this drops the queued delivery; no undo.`,
-        });
-        cancelForm.append(el('button', { type: 'submit', class: 'btn btn-deny' }, '✗ C4NC3L'));
-        actions.append(cancelForm);
-        li.append(actions);
-        ul.append(li);
-      }
-      root.append(ul);
-    });
-  }
-  // ─── scheduled prompts ─────────────────────────────────────────────────
-  // Backend exposes `/api/schedules` (snapshot), `/api/schedules`
-  // (POST, operator-direct submit), `/api/schedules/{id}/cancel`
-  // (whole or per-target), `/api/schedules/{id}` (PATCH edit),
-  // `/api/schedules/{id}/fire-now` (POST). Mutations now emit a
-  // `schedules_changed` SSE event so the list updates live;
-  // `applySchedulesChanged` handles it. Tab-activation re-fetch kept as
-  // a safety net for approval-path inserts and disconnect windows.
-  // Local cache lets `refreshTabCounts` show the active count without
-  // re-fetching every second.
-  let schedulesState = [];
-  // Schedule ids whose inline edit form is currently open. The set
-  // survives across refreshSchedules() calls so a state
-  // poll doesn't yank the form out from under the operator. Per-id
-  // mid-edit carry sits in `scheduleEditCarry` so unsaved typing
-  // also rides the refresh.
-  const editingSchedules = new Set();
-  const scheduleEditCarry = new Map();
-  async function refreshSchedules() {
-    const listRoot = $('schedules-section');
-    if (!listRoot) return;
-    try {
-      const resp = await fetch('/api/schedules');
-      if (!resp.ok) {
-        paintAtomic(listRoot, (root) => {
-          root.append(el('p', { class: 'empty' }, 'schedules unavailable: http ' + resp.status));
-        });
-        return;
-      }
-      schedulesState = await resp.json();
-    } catch (err) {
-      paintAtomic(listRoot, (root) => {
-        root.append(el('p', { class: 'empty' }, 'schedules fetch failed: ' + err));
-      });
-      return;
-    }
-    renderSchedulesList();
-  }
-  // Active = at least one target still alive (no `cancelled_at_unix`)
-  // AND the whole schedule isn't cancelled. Drives the tab pill count.
-  function activeScheduleCount() {
-    let n = 0;
-    for (const s of schedulesState) {
-      if (s.cancelled_at_unix) continue;
-      if ((s.targets || []).some((t) => !t.cancelled_at_unix)) n++;
-    }
-    return n;
-  }
-  // Label + caption wrapper shared by every field on the schedule
-  // forms — `<label class="schedule-field"><span
-  // class="schedule-field-label">…</span>…children…</label>`. Variadic
-  // children land inside the label after the caption span, which is
-  // what every caller wants (the input + any preset/parts/preview
-  // sub-rows live next to the caption).
-  function scheduleField(labelText, ...children) {
-    return el('label', { class: 'schedule-field' },
-      el('span', { class: 'schedule-field-label' }, labelText),
-      ...children);
-  }
-
-  // Interval composer — shared between the new-schedule form and
-  // the edit-schedule form. Builds the preset chip row +
-  // d/h/m/s sub-fields + live preview, and returns helpers to read
-  // and write the value.
-  //
-  // The composer carries no opinion on what "0 / blank" means at the
-  // semantic layer: it just reports the integer total. Callers decide
-  // whether to treat 0 as `null` (one-shot) for their own submit path.
-  function buildIntervalComposer({
-    label = 'interval (blank / all-zero = one-shot)',
-    namePrefix = 'interval_',
-    initialSeconds = 0,
-  } = {}) {
-    const wrapper = scheduleField(label);
-    const presets = [
-      ['1m', 60], ['5m', 300], ['15m', 900], ['30m', 1800],
-      ['1h', 3600], ['6h', 21600], ['12h', 43200],
-      ['1d', 86400], ['7d', 604800],
-    ];
-    const presetsRow = el('div', { class: 'schedule-interval-presets' });
-    for (const [presetLabel, secs] of presets) {
-      presetsRow.append(el('button', {
-        type: 'button',
-        class: 'btn btn-interval-preset',
-        'data-secs': String(secs),
-      }, presetLabel));
-    }
-    presetsRow.append(el('button', {
-      type: 'button',
-      class: 'btn btn-interval-preset btn-interval-oneshot',
-      'data-secs': '0',
-    }, 'one-shot'));
-    wrapper.append(presetsRow);
-
-    const partsRow = el('div', { class: 'schedule-interval-parts' });
-    const mkPart = (suffix, unit) => {
-      const inp = el('input', {
-        type: 'number', name: namePrefix + suffix, min: '0', step: '1', placeholder: '0',
-        class: 'schedule-interval-num',
-      });
-      partsRow.append(inp, el('span', { class: 'schedule-interval-unit' }, unit));
-      return inp;
-    };
-    const dInp = mkPart('d', 'd');
-    const hInp = mkPart('h', 'h');
-    const mInp = mkPart('m', 'm');
-    const sInp = mkPart('s', 's');
-    wrapper.append(partsRow);
-
-    const preview = el('div', { class: 'schedule-interval-preview', 'aria-live': 'polite' });
-    wrapper.append(preview);
-
-    function getSeconds() {
-      const n = (v) => {
-        const x = parseInt(v, 10);
-        return Number.isFinite(x) && x > 0 ? x : 0;
-      };
-      return n(dInp.value) * 86400 + n(hInp.value) * 3600
-        + n(mInp.value) * 60 + n(sInp.value);
-    }
-    function fillFromSeconds(total) {
-      const t = Math.max(0, Math.floor(total));
-      const d = Math.floor(t / 86400);
-      const h = Math.floor((t % 86400) / 3600);
-      const m = Math.floor((t % 3600) / 60);
-      const s = t % 60;
-      dInp.value = d > 0 ? String(d) : '';
-      hInp.value = h > 0 ? String(h) : '';
-      mInp.value = m > 0 ? String(m) : '';
-      sInp.value = s > 0 ? String(s) : '';
-    }
-    function setParts({ d, h, m, s }) {
-      if (d !== undefined) dInp.value = d;
-      if (h !== undefined) hInp.value = h;
-      if (m !== undefined) mInp.value = m;
-      if (s !== undefined) sInp.value = s;
-    }
-    function updatePreview() {
-      const total = getSeconds();
-      preview.textContent = total > 0
-        ? '↻ every ' + fmtDuration(total)
-        : 'one-shot (fires once at first-fire time)';
-      preview.classList.toggle('schedule-interval-preview-oneshot', total === 0);
-    }
-    for (const inp of [dInp, hInp, mInp, sInp]) {
-      inp.addEventListener('input', updatePreview);
-    }
-    for (const b of presetsRow.querySelectorAll('button[data-secs]')) {
-      b.addEventListener('click', () => {
-        fillFromSeconds(parseInt(b.getAttribute('data-secs'), 10) || 0);
-        updatePreview();
-      });
-    }
-    if (initialSeconds > 0) fillFromSeconds(initialSeconds);
-    updatePreview();
-
-    return { wrapper, getSeconds, fillFromSeconds, setParts, updatePreview };
-  }
-
-  // Parse the d/h/m/s sub-fields of a `buildIntervalComposer` instance
-  // out of submitted FormData. Returns total seconds, or NaN if any
-  // field carries a non-integer / negative value — the caller alerts
-  // and bails. Total `0` means "one-shot" at the call site (wire is
-  // `interval_seconds: null`). `namePrefix` matches the prefix passed
-  // to `buildIntervalComposer` (e.g. `interval_` or `edit_interval_`).
-  function intervalSecondsFromFormData(fd, namePrefix) {
-    const part = (suffix, mult) => {
-      const raw = String(fd.get(namePrefix + suffix) || '').trim();
-      if (!raw) return 0;
-      const n = parseInt(raw, 10);
-      if (!Number.isFinite(n) || n < 0) return NaN;
-      return n * mult;
-    };
-    return part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
-  }
-
-  // Targets multi-select chip box — shared between the new-schedule
-  // form and the edit-schedule form. Same DOM shape, same candidate
-  // list (containers + operator + root); only the chip element id
-  // prefix and checkbox field name vary. Used to be inlined twice in
-  // near-identical 18-line blocks; consolidated here so a future
-  // change (new chip kind, candidate-list source swap, etc.) lives in
-  // one place. Returns the wrapping `<label class="schedule-field">`
-  // ready to append to the form.
-  function buildTargetChips({ idPrefix, fieldName, checked, extraNames = [] }) {
-    const candidates = ['operator'];
-    const containerNames = Array.from(containersState.values())
-      .map((c) => c.name)
-      .filter((n) => n !== 'operator')
-      .sort();
-    for (const n of containerNames) candidates.push(n);
-    // `extraNames` lets the edit form keep showing an already-active
-    // target that's vanished from the live container list (operator's
-    // typo, container destroyed mid-schedule, etc.) so it's still
-    // explicitly uncheckable. New-schedule callers pass `[]`.
-    for (const n of extraNames) if (!candidates.includes(n)) candidates.push(n);
-
-    const box = el('div', { class: 'schedule-targets' });
-    for (const name of candidates) {
-      const id_ = idPrefix + name;
-      const cb = el('input', {
-        type: 'checkbox', name: fieldName, value: name, id: id_,
-      });
-      if (checked.has(name)) cb.checked = true;
-      box.append(el('label', { class: 'schedule-target-chip', for: id_ },
-        cb, el('span', {}, name)));
-    }
-    return scheduleField('targets', box);
-  }
-
-  // Inline-create carry-state — survives paintAtomic re-renders.
-  // The schedules table refreshes on tab activate + after every mutation,
-  // and each refresh rebuilds the DOM via `paintAtomic`. The bottom
-  // create row's inputs would lose mid-typing values without this
-  // carry. `readNewScheduleCarryFromDOM` is called BEFORE every
-  // re-render so the carry sees the latest user input; the row
-  // builders then pre-fill from `newScheduleCarry`.
-  const newScheduleCarry = {
-    targets: new Set(),
-    body: '',
-    description: '',
-    first_fire: '',
-    interval_d: '',
-    interval_h: '',
-    interval_m: '',
-    interval_s: '',
-  };
-  function readNewScheduleCarryFromDOM(tr) {
-    if (!tr) return;
-    const get = (sel) => tr.querySelector(sel);
-    const checked = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
-      .map((i) => i.value);
-    newScheduleCarry.targets = new Set(checked);
-    const setIfDefined = (key, sel) => {
-      const el_ = get(sel);
-      if (el_) newScheduleCarry[key] = el_.value || '';
-    };
-    setIfDefined('body', 'textarea[name="new_body"]');
-    setIfDefined('description', 'input[name="new_description"]');
-    setIfDefined('first_fire', 'input[name="new_first_fire"]');
-    setIfDefined('interval_d', 'input[name="new_interval_d"]');
-    setIfDefined('interval_h', 'input[name="new_interval_h"]');
-    setIfDefined('interval_m', 'input[name="new_interval_m"]');
-    setIfDefined('interval_s', 'input[name="new_interval_s"]');
-  }
-  function resetNewScheduleCarry() {
-    newScheduleCarry.targets = new Set();
-    newScheduleCarry.body = '';
-    newScheduleCarry.description = '';
-    newScheduleCarry.first_fire = '';
-    newScheduleCarry.interval_d = '';
-    newScheduleCarry.interval_h = '';
-    newScheduleCarry.interval_m = '';
-    newScheduleCarry.interval_s = '';
-  }
-  function isoForDatetimeLocal(date) {
-    // `<input type="datetime-local">` expects `YYYY-MM-DDTHH:MM`
-    // in the user's local timezone (with no trailing Z). Build it
-    // by hand rather than slicing toISOString which is always UTC.
-    const pad = (n) => String(n).padStart(2, '0');
-    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`
-      + `T${pad(date.getHours())}:${pad(date.getMinutes())}`;
-  }
-  // Schedules render as a single table — one row per schedule,
-  // attribute columns + one ✓/✕ column per agent (tilted 45° header
-  // so a row of agents takes ~28px each instead of full word width),
-  // actions column on the right. Edit form expands into a colspan'd
-  // row underneath when its row's `✎` is toggled on.
-  function renderSchedulesList() {
-    const liveRoot = $('schedules-section');
-    if (!liveRoot) return;
-    // Capture any mid-typed inline-create state BEFORE paintAtomic
-    // blows the row away so a refresh doesn't yank the operator's
-    // half-filled form. The carry is replayed by
-    // `renderInlineCreateRow` below.
-    readNewScheduleCarryFromDOM(liveRoot.querySelector('.schedules-table-create-row'));
-    paintAtomic(liveRoot, (root) => {
-      const agents = schedulesTableAgentSet();
-      const table = el('table', { class: 'schedules-table' });
-      table.append(renderSchedulesTableHead(agents));
-      const tbody = el('tbody', {});
-      const sorted = schedulesState.slice().sort((a, b) => {
-        const aDone = a.cancelled_at_unix ? 1 : 0;
-        const bDone = b.cancelled_at_unix ? 1 : 0;
-        if (aDone !== bDone) return aDone - bDone;
-        return a.next_fire_at_unix - b.next_fire_at_unix;
-      });
-      for (const s of sorted) {
-        tbody.append(renderScheduleRow(s, agents));
-        if (editingSchedules.has(s.id) && !s.cancelled_at_unix) {
-          tbody.append(renderScheduleEditRow(s, agents));
-        }
-      }
-      // Always-visible inline create row at the bottom of the table
-      // — fill cells + click ＋ to POST. See
-      // docs/web-ui.md::SCH3DUL3S tab for the layout rationale.
-      tbody.append(renderInlineCreateRow(agents));
-      table.append(tbody);
-      const wrap = el('div', { class: 'schedules-table-wrap' });
-      wrap.append(table);
-      root.append(wrap);
-    });
-  }
-  // Inline create row. Each column carries an input matching its
-  // display semantics (datetime-local for next-fire, mini d/h/m/s
-  // number inputs for every, textarea for body, checkbox per agent
-  // column for targets). Submitting POSTs `/api/schedules` and clears
-  // the carry on success; the next `refreshSchedules` redraws the
-  // table with the new schedule above.
-  function renderInlineCreateRow(agents) {
-    const tr = el('tr', { class: 'schedules-table-create-row' });
-
-    tr.append(el('td', { class: 'meta schedules-table-id' }, 'new'));
-    tr.append(el('td', { class: 'meta' }, '—'));
-
-    const nextInput = el('input', {
-      type: 'datetime-local',
-      name: 'new_first_fire',
-      class: 'schedules-table-inline-input schedules-table-inline-datetime',
-      required: 'required',
-      title: 'first fire time (defaults to 5 minutes from now)',
-    });
-    // Default: 5 minutes from now so a stale-clock or quick-submit
-    // accident doesn't fire immediately on `now()`.
-    nextInput.value = newScheduleCarry.first_fire
-      || isoForDatetimeLocal(new Date(Date.now() + 5 * 60 * 1000));
-    tr.append(el('td', { class: 'schedules-table-create-cell' }, nextInput));
-
-    const intervalRow = el('div', {
-      class: 'schedules-table-inline-interval',
-      title: 'recurring every D days H hours M minutes S seconds (all blank / zero = one-shot)',
-    });
-    const mkUnit = (suffix, unit) => {
-      const inp = el('input', {
-        type: 'number',
-        name: 'new_interval_' + suffix,
-        min: '0',
-        step: '1',
-        placeholder: '0',
-        class: 'schedules-table-inline-num',
-        'aria-label': 'interval ' + suffix,
-      });
-      inp.value = newScheduleCarry['interval_' + suffix] || '';
-      intervalRow.append(inp, el('span', { class: 'schedules-table-inline-unit' }, unit));
-    };
-    mkUnit('d', 'd');
-    mkUnit('h', 'h');
-    mkUnit('m', 'm');
-    mkUnit('s', 's');
-    tr.append(el('td', { class: 'schedules-table-create-cell' }, intervalRow));
-
-    tr.append(el('td', { class: 'meta' }, 'operator'));
-
-    const bodyTa = el('textarea', {
-      name: 'new_body',
-      rows: '1',
-      required: 'required',
-      placeholder: 'prompt body (required, multi-line ok)',
-      class: 'schedules-table-inline-textarea',
-    });
-    bodyTa.value = newScheduleCarry.body;
-    const descInput = el('input', {
-      type: 'text',
-      name: 'new_description',
-      placeholder: 'description (optional)',
-      class: 'schedules-table-inline-input schedules-table-inline-desc',
-    });
-    descInput.value = newScheduleCarry.description;
-    tr.append(el('td', { class: 'schedules-table-create-cell schedules-table-create-body' },
-      bodyTa, descInput));
-
-    // Per-agent target checkboxes — one cell per agent column. Wrap
-    // each checkbox in a label so the whole cell area is clickable.
-    for (const a of agents) {
-      const td = el('td', { class: 'schedules-table-check schedules-table-create-cell' });
-      const id_ = 'new-target-' + a;
-      const cb = el('input', {
-        type: 'checkbox',
-        name: 'new_targets',
-        value: a,
-        id: id_,
-        class: 'schedules-table-inline-check',
-      });
-      if (newScheduleCarry.targets.has(a)) cb.checked = true;
-      const lbl = el('label', {
-        for: id_,
-        class: 'schedules-table-inline-check-lbl',
-        title: 'tick to target ' + a,
-      }, cb);
-      td.append(lbl);
-      tr.append(td);
-    }
-
-    // Actions cell — submit button + reset.
-    const actionsCell = el('td', { class: 'schedules-table-actions' });
-    const submitBtn = el('button', {
-      type: 'button',
-      class: 'btn btn-spawn btn-inline-small schedules-table-create-submit',
-      title: 'queue this new schedule',
-    }, '＋');
-    submitBtn.addEventListener('click', () => submitNewScheduleInline(tr, submitBtn));
-    const resetBtn = el('button', {
-      type: 'button',
-      class: 'btn btn-inline-small schedules-table-create-reset',
-      title: 'clear all fields',
-    }, '⌫');
-    resetBtn.addEventListener('click', () => {
-      resetNewScheduleCarry();
-      renderSchedulesList();
-    });
-    actionsCell.append(submitBtn, resetBtn);
-    tr.append(actionsCell);
-
-    return tr;
-  }
-  async function submitNewScheduleInline(tr, submitBtn) {
-    const targets = Array.from(tr.querySelectorAll('input[name="new_targets"]:checked'))
-      .map((i) => i.value);
-    const body = String(tr.querySelector('textarea[name="new_body"]')?.value || '').trim();
-    const description = String(tr.querySelector('input[name="new_description"]')?.value || '').trim();
-    const firstFireStr = String(tr.querySelector('input[name="new_first_fire"]')?.value || '');
-
-    if (!targets.length) {
-      alert('schedule must have at least one target — tick at least one agent column');
-      return;
-    }
-    if (!body) { alert('prompt body must be non-empty'); return; }
-    if (!firstFireStr) { alert('first fire timestamp is required'); return; }
-    const firstFireDate = new Date(firstFireStr);
-    if (Number.isNaN(firstFireDate.getTime())) {
-      alert('first fire is not a valid datetime'); return;
-    }
-    const first_fire_at_unix = Math.floor(firstFireDate.getTime() / 1000);
-
-    // Parse the d/h/m/s parts inline — we don't use FormData since
-    // the inline row isn't wrapped in a <form>. Mirrors
-    // `intervalSecondsFromFormData` semantics: blank/0 = one-shot,
-    // anything non-integer or negative → NaN → alert.
-    const part = (suffix, mult) => {
-      const raw = String(tr.querySelector(`input[name="new_interval_${suffix}"]`)?.value || '').trim();
-      if (!raw) return 0;
-      const n = parseInt(raw, 10);
-      if (!Number.isFinite(n) || n < 0) return NaN;
-      return n * mult;
-    };
-    const intervalTotal = part('d', 86400) + part('h', 3600) + part('m', 60) + part('s', 1);
-    if (Number.isNaN(intervalTotal)) {
-      alert('interval fields must be non-negative integers (or blank for one-shot)');
-      return;
-    }
-    const interval_seconds = intervalTotal > 0 ? intervalTotal : null;
-
-    const payload = { targets, body, first_fire_at_unix };
-    if (interval_seconds != null) payload.interval_seconds = interval_seconds;
-    if (description) payload.description = description;
-
-    const originalLabel = submitBtn.innerHTML;
-    submitBtn.disabled = true;
-    submitBtn.innerHTML = '<span class="spinner">◐</span>';
-    try {
-      const resp = await fetch('/api/schedules', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-      });
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => '');
-        alert('schedule submit failed: http ' + resp.status + (text ? '\n\n' + text : ''));
-        return;
-      }
-      // Reset carry so the next render shows an empty row.
-      resetNewScheduleCarry();
-      await refreshSchedules();
-    } catch (err) {
-      alert('schedule submit failed: ' + err);
-    } finally {
-      submitBtn.disabled = false;
-      submitBtn.innerHTML = originalLabel;
-    }
-  }
-  // The set of agent columns in the schedules table: operator + root
-  // (manager) first, then live containers (sorted), then any extra names
-  // that appear as a schedule target but aren't in the live container list
-  // (operator typo, container destroyed mid-schedule, etc.) — same
-  // membership rule as `buildTargetChips` so the table and the new-/
-  // edit-form chip boxes agree on what's addressable.
-  function schedulesTableAgentSet() {
-    const seen = new Set();
-    const out = [];
-    const push = (n) => { if (!seen.has(n)) { seen.add(n); out.push(n); } };
-    push('operator');
-    const containerNames = Array.from(containersState.values())
-      .map((c) => c.name)
-      .filter((n) => n !== 'operator')
-      .sort();
-    for (const n of containerNames) push(n);
-    for (const s of schedulesState) {
-      for (const t of s.targets || []) push(t.target);
-    }
-    return out;
-  }
-  function renderSchedulesTableHead(agents) {
-    const thead = el('thead', {});
-    const headerRow = el('tr', {});
-    headerRow.append(
-      el('th', { class: 'schedules-table-id' }, '#'),
-      el('th', {}, 'src'),
-      el('th', { class: 'schedules-table-next-col' }, 'next'),
-      el('th', { class: 'schedules-table-every-col' }, 'every'),
-      el('th', {}, 'owner'),
-      el('th', { class: 'schedules-table-body-th' }, 'body'),
-    );
-    for (const a of agents) {
-      headerRow.append(el('th', { class: 'schedules-table-agent-th', title: a },
-        el('div', {}, el('span', {}, a))));
-    }
-    headerRow.append(el('th', { class: 'schedules-table-actions-th' }, ''));
-    thead.append(headerRow);
-    return thead;
-  }
-  function renderScheduleRow(s, agents) {
-    const cancelled = !!s.cancelled_at_unix;
-    const tr = el('tr', {
-      class: 'schedules-table-row' + (cancelled ? ' schedules-table-row-cancelled' : ''),
-    });
-
-    tr.append(el('td', { class: 'meta schedules-table-id' }, '#' + s.id));
-
-    const srcKind = s.source && s.source.kind === 'approval' ? 'approval' : 'manual';
-    tr.append(el('td', {},
-      el('span', { class: 'rqe-source rqe-source-' + srcKind },
-        srcKind === 'approval' ? 'approval' : 'operator')));
-
-    // "next" cell — relative due-in for active schedules, "cancelled"
-    // for cancelled ones. Both carry the absolute ISO in the title.
-    const nextCell = el('td', { class: 'meta schedules-table-next-col' });
-    if (cancelled) {
-      nextCell.title = 'cancelled ' + new Date(s.cancelled_at_unix * 1000).toISOString();
-      nextCell.textContent = 'cancelled';
-    } else {
-      const dueIn = s.next_fire_at_unix - Math.floor(Date.now() / 1000);
-      nextCell.title = new Date(s.next_fire_at_unix * 1000).toISOString();
-      nextCell.textContent = dueIn <= 0
-        ? 'overdue ' + fmtAgo(s.next_fire_at_unix)
-        : fmtDuration(dueIn);
-      nextCell.classList.add('sched-due');
-      nextCell.dataset.dueAt = String(s.next_fire_at_unix);
-    }
-    tr.append(nextCell);
-
-    tr.append(el('td', { class: 'meta schedules-table-every-col' },
-      s.interval_seconds ? '↻ ' + fmtDuration(s.interval_seconds) : 'one-shot'));
-
-    tr.append(el('td', { class: 'meta' }, s.owner));
-
-    // Body cell — truncates with ellipsis; full body + description (if
-    // any) on hover. Description used to be a separate visible block on
-    // the card layout; the table compresses it into the title to keep
-    // row height tight. Mara nit-flag candidate if she actually wants
-    // it visible in-table.
-    const bodyCell = el('td', { class: 'schedules-table-body-cell' });
-    const bodyText = s.body || '';
-    bodyCell.title = (s.description ? s.description + '\n\n' : '') + bodyText;
-    bodyCell.textContent = bodyText;
-    tr.append(bodyCell);
-
-    // Per-agent target cells. Three states:
-    //   - active target → ✓ button that cancels just that target on
-    //     click (same affordance as the per-row ✕ on the old layout's
-    //     targets table)
-    //   - cancelled target → muted ✕ glyph (no button — backend
-    //     re-add flows through the edit form's targets multi-select)
-    //   - not a target → empty cell
-    const targetByName = new Map();
-    for (const t of s.targets || []) targetByName.set(t.target, t);
-    for (const a of agents) {
-      const t = targetByName.get(a);
-      const td = el('td', { class: 'schedules-table-check' });
-      if (!t) {
-        // empty — no button, no glyph
-      } else if (t.cancelled_at_unix) {
-        td.title = 'cancelled — '
-          + (t.last_fired_at_unix
-            ? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
-            : 'never fired')
-          + (t.last_result ? ' · ' + t.last_result : '');
-        td.append(el('span', { class: 'schedules-table-check-cancelled' }, '✕'));
-      } else {
-        const lastFireDesc = t.last_fired_at_unix
-          ? 'last fired ' + fmtAgo(t.last_fired_at_unix) + ' ago'
-          : 'never fired';
-        const lastResultDesc = t.last_result ? ' · ' + t.last_result : '';
-        const checkBtn = el('button', {
-          type: 'button',
-          class: 'schedules-table-check-btn',
-        }, '✓');
-        checkBtn.title = lastFireDesc + lastResultDesc
-          + (cancelled ? '' : '\nclick to cancel this target');
-        if (cancelled) {
-          checkBtn.disabled = true;
-        } else {
-          checkBtn.addEventListener('click', () => cancelScheduleTargets(s.id, [a]));
-        }
-        td.append(checkBtn);
-      }
-      tr.append(td);
-    }
-
-    // Actions cell — fire / edit / cancel-all. Glyph-only to fit a
-    // compact column; the buttons keep their existing colour classes
-    // so the visual cue (mauve = fire, yellow = edit, red = cancel)
-    // carries over from the card layout.
-    const actionsCell = el('td', { class: 'schedules-table-actions' });
-    if (!cancelled) {
-      const activeTargets = (s.targets || []).filter((t) => !t.cancelled_at_unix);
-      const isOneShot = !s.interval_seconds;
-      const fireBtn = el('button', {
-        type: 'button',
-        class: 'btn btn-fire-now btn-inline-small',
-      }, '↯');
-      fireBtn.title = isOneShot
-        ? 'fire once — one-shot, consumed after the manual fire'
-        : 'fire once now — recurring, next regular fire unaffected';
-      if (!activeTargets.length) {
-        fireBtn.disabled = true;
-        fireBtn.title = 'every target is cancelled — nothing to fire';
-      }
-      fireBtn.addEventListener('click', () =>
-        fireScheduleNow(s.id, isOneShot, activeTargets.map((t) => t.target), fireBtn));
-      actionsCell.append(fireBtn);
-
-      const editingThis = editingSchedules.has(s.id);
-      const editBtn = el('button', {
-        type: 'button',
-        class: 'btn btn-edit-schedule btn-inline-small',
-      }, editingThis ? '✎×' : '✎');
-      editBtn.title = editingThis
-        ? 'close edit'
-        : 'edit body / description / interval / next-fire / targets';
-      editBtn.addEventListener('click', () => {
-        if (editingThis) {
-          editingSchedules.delete(s.id);
-          scheduleEditCarry.delete(s.id);
-        } else {
-          editingSchedules.add(s.id);
-        }
-        renderSchedulesList();
-      });
-      actionsCell.append(editBtn);
-
-      const cancelBtn = el('button', {
-        type: 'button',
-        class: 'btn btn-deny btn-inline-small',
-      }, '✕');
-      cancelBtn.title = 'cancel the whole schedule';
-      cancelBtn.addEventListener('click', () => cancelScheduleAll(s.id));
-      actionsCell.append(cancelBtn);
-    }
-    tr.append(actionsCell);
-
-    return tr;
-  }
-  function renderScheduleEditRow(s, agents) {
-    // colspan = 6 attribute cols + N agent cols + 1 actions col
-    const colCount = 7 + agents.length;
-    const tr = el('tr', { class: 'schedules-table-edit-row' });
-    const td = el('td', { colspan: String(colCount) });
-    td.append(renderScheduleEditForm(s));
-    tr.append(td);
-    return tr;
-  }
-
-  // Inline edit form. Renders inside the schedule row when the
-  // row's `✎ edit` button is toggled on. Pre-filled with current
-  // values; submit PATCHes /api/schedules/{id}. Targets stay
-  // immutable (per damocles's backend; the workaround for retargeting
-  // is cancel + new schedule). Mid-edit field values survive a
-  // state-poll refresh via `scheduleEditCarry`.
-  function renderScheduleEditForm(s) {
-    const wrapper = el('div', { class: 'schedule-edit-form-wrapper' });
-    const form_ = el('form', { class: 'schedule-edit-form' });
-    form_.addEventListener('submit', (e) => {
-      e.preventDefault();
-      submitEditSchedule(s, form_);
-    });
-
-    const carry = scheduleEditCarry.get(s.id) || {};
-
-    const bodyInput = el('textarea', { name: 'body', rows: '4', required: 'required' });
-    bodyInput.value = carry.body !== undefined ? carry.body : s.body;
-    form_.append(scheduleField('body', bodyInput));
-
-    const descInput = el('input', { type: 'text', name: 'description' });
-    descInput.value = carry.description !== undefined
-      ? carry.description
-      : (s.description || '');
-    form_.append(scheduleField('description (blank to clear)', descInput));
-
-    const firstFireInput = el('input', {
-      type: 'datetime-local', name: 'next_fire', required: 'required',
-    });
-    firstFireInput.value = carry.next_fire !== undefined
-      ? carry.next_fire
-      : isoForDatetimeLocal(new Date(s.next_fire_at_unix * 1000));
-    form_.append(scheduleField('next fire', firstFireInput));
-
-    const intervalCx = buildIntervalComposer({
-      label: 'interval (blank / all-zero = flip to one-shot)',
-      namePrefix: 'edit_interval_',
-      initialSeconds: 0,
-    });
-    form_.append(intervalCx.wrapper);
-    if (carry.interval_d !== undefined || carry.interval_h !== undefined
-        || carry.interval_m !== undefined || carry.interval_s !== undefined) {
-      intervalCx.setParts({
-        d: carry.interval_d || '',
-        h: carry.interval_h || '',
-        m: carry.interval_m || '',
-        s: carry.interval_s || '',
-      });
-    } else if (s.interval_seconds) {
-      intervalCx.fillFromSeconds(s.interval_seconds);
-    }
-    intervalCx.updatePreview();
-
-    // Persist carry on every input + checkbox change so a refresh
-    // repaint preserves it.
-    const saveCarry = () => {
-      const fd = new FormData(form_);
-      scheduleEditCarry.set(s.id, {
-        body: String(fd.get('body') || ''),
-        description: String(fd.get('description') || ''),
-        next_fire: String(fd.get('next_fire') || ''),
-        interval_d: String(fd.get('edit_interval_d') || ''),
-        interval_h: String(fd.get('edit_interval_h') || ''),
-        interval_m: String(fd.get('edit_interval_m') || ''),
-        interval_s: String(fd.get('edit_interval_s') || ''),
-        targets: fd.getAll('edit_targets').map(String),
-      });
-    };
-    form_.addEventListener('input', saveCarry);
-    form_.addEventListener('change', saveCarry);
-
-    // Targets multi-select. Shares the chip-box pattern with the
-    // new-schedule form via `buildTargetChips`;
-    // cancelled tombstones aren't listed (re-adding them flows
-    // through `targets_add`, which the backend replace-on-conflict
-    // drops the tombstone for). Submit diffs against the original
-    // active set to populate `targets_add` / `targets_remove` on the
-    // PATCH body.
-    const originalActiveTargets = new Set(
-      (s.targets || []).filter((t) => !t.cancelled_at_unix).map((t) => t.target),
-    );
-    form_.append(buildTargetChips({
-      idPrefix: 'se-' + s.id + '-',
-      fieldName: 'edit_targets',
-      checked: carry.targets ? new Set(carry.targets) : originalActiveTargets,
-      extraNames: [...originalActiveTargets],
-    }));
-    form_.append(el('p', { class: 'meta schedule-edit-targets-note' },
-      're-adding a previously cancelled target drops its history and starts fresh; '
-      + 'unchecking an active target cancels it.'));
-
-    const actions = el('div', { class: 'schedule-actions' });
-    const submit = el('button', { type: 'submit', class: 'btn btn-spawn' }, '✓ save changes');
-    const cancelEdit = el('button', { type: 'button', class: 'btn' }, 'cancel');
-    cancelEdit.addEventListener('click', () => {
-      editingSchedules.delete(s.id);
-      scheduleEditCarry.delete(s.id);
-      renderSchedulesList();
-    });
-    actions.append(submit, cancelEdit);
-    form_.append(actions);
-
-    wrapper.append(form_);
-    return wrapper;
-  }
-
-  async function submitEditSchedule(originalSchedule, form_) {
-    const s = originalSchedule;
-    const fd = new FormData(form_);
-    const newBody = String(fd.get('body') || '').trim();
-    const newDescription = String(fd.get('description') || '').trim();
-    const newNextFireStr = String(fd.get('next_fire') || '');
-
-    if (!newBody) { alert('body must be non-empty'); return; }
-    if (!newNextFireStr) { alert('next-fire timestamp is required'); return; }
-    const newNextFireDate = new Date(newNextFireStr);
-    if (Number.isNaN(newNextFireDate.getTime())) {
-      alert('next-fire is not a valid datetime'); return;
-    }
-    const newNextFireUnix = Math.floor(newNextFireDate.getTime() / 1000);
-
-    // Compute interval total from the d/h/m/s fields (composer uses
-    // `edit_interval_*` names in this form).
-    const intervalTotal = intervalSecondsFromFormData(fd, 'edit_interval_');
-    if (Number.isNaN(intervalTotal)) {
-      alert('interval fields must be non-negative integers');
-      return;
-    }
-    const newIntervalSeconds = intervalTotal > 0 ? intervalTotal : null;
-
-    // Compute target diff against the schedule's currently-active set
-    // (cancelled tombstones don't count). The backend treats
-    // `targets_add` as replace-on-conflict (re-adding a tombstoned
-    // target drops its history), so we can just blanket "send the
-    // checked list as add, send the unchecked-but-was-active list as
-    // remove."
-    const newTargets = new Set(fd.getAll('edit_targets').map(String));
-    const originalActive = new Set(
-      (s.targets || [])
-        .filter((t) => !t.cancelled_at_unix)
-        .map((t) => t.target),
-    );
-    if (!newTargets.size) {
-      alert('schedule must have at least one target — uncheck submit, or use ✕ cancel all instead');
-      return;
-    }
-    const targetsAdd = [...newTargets].filter((t) => !originalActive.has(t));
-    const targetsRemove = [...originalActive].filter((t) => !newTargets.has(t));
-
-    // Build the PATCH body. Only include keys for fields that
-    // actually changed; explicit `null` clears description / flips
-    // recurring→one-shot. `targets_add` / `targets_remove` only
-    // populated when non-empty so the wire body stays minimal.
-    const patch = {};
-    if (newBody !== s.body) patch.body = newBody;
-    if (newDescription !== (s.description || '')) {
-      patch.description = newDescription || null;
-    }
-    if (newNextFireUnix !== s.next_fire_at_unix) {
-      patch.next_fire_at_unix = newNextFireUnix;
-    }
-    if (newIntervalSeconds !== (s.interval_seconds || null)) {
-      patch.interval_seconds = newIntervalSeconds;
-    }
-    if (targetsAdd.length) patch.targets_add = targetsAdd;
-    if (targetsRemove.length) patch.targets_remove = targetsRemove;
-    if (!Object.keys(patch).length) {
-      // No-op submit. Treat as "close edit form".
-      editingSchedules.delete(s.id);
-      scheduleEditCarry.delete(s.id);
-      renderSchedulesList();
-      return;
-    }
-
-    const submitBtn = form_.querySelector('button[type="submit"]');
-    const originalLabel = submitBtn ? submitBtn.textContent : '';
-    if (submitBtn) { submitBtn.disabled = true; submitBtn.textContent = 'saving…'; }
-    try {
-      const resp = await fetch('/api/schedules/' + encodeURIComponent(s.id), {
-        method: 'PATCH',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(patch),
-      });
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => '');
-        alert('edit failed: http ' + resp.status + (text ? '\n\n' + text : ''));
-        return;
-      }
-      editingSchedules.delete(s.id);
-      scheduleEditCarry.delete(s.id);
-      await refreshSchedules();
-    } catch (err) {
-      alert('edit failed: ' + err);
-    } finally {
-      if (submitBtn) { submitBtn.disabled = false; submitBtn.textContent = originalLabel; }
-    }
-  }
-  async function fireScheduleNow(id, isOneShot, targets, btn) {
-    const targetList = targets.length ? targets.join(', ') : '(no active targets)';
-    const prompt = isOneShot
-      ? `fire schedule #${id} now to ${targetList}?\n\n`
-        + 'this is a ONE-SHOT — firing now consumes the schedule. '
-        + 'the scheduled fire time will no longer trigger.'
-      : `fire schedule #${id} now to ${targetList}?\n\n`
-        + 'this is RECURRING — sends an extra pulse out-of-band. '
-        + 'the regular cadence keeps firing on schedule.';
-    if (!confirm(prompt)) return;
-    // Capture child nodes so we can restore on error, then replace
-    // with DOM-built content (textContent + element children rather
-    // than innerHTML — the format string only carries server-side
-    // ints/bool today but textContent is the safer pattern if a
-    // stringy field ever lands).
-    const originalChildren = btn ? Array.from(btn.childNodes) : [];
-    const restoreBtn = () => {
-      if (!btn) return;
-      btn.disabled = false;
-      while (btn.firstChild) btn.removeChild(btn.firstChild);
-      for (const n of originalChildren) btn.appendChild(n);
-    };
-    if (btn) {
-      btn.disabled = true;
-      while (btn.firstChild) btn.removeChild(btn.firstChild);
-      btn.append(el('span', { class: 'spinner' }, '◐'), ' firing…');
-    }
-    try {
-      const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/fire-now', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-      });
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => '');
-        alert('fire-now failed: http ' + resp.status + (text ? '\n\n' + text : ''));
-        restoreBtn();
-        return;
-      }
-      // Backend returns FireNowReport { ok, failed, missing, one_shot_consumed }.
-      // Flash the per-target outcome on the button itself so the operator
-      // sees the result immediately, then refresh to pick up the
-      // authoritative per-target `last_result` annotations.
-      let report = null;
-      try { report = await resp.json(); } catch { /* shape drift / empty body — ignore */ }
-      if (btn && report) {
-        const bits = [];
-        if (report.ok) bits.push(report.ok + ' ok');
-        if (report.failed) bits.push(report.failed + ' failed');
-        if (report.missing) bits.push(report.missing + ' missing');
-        const suffix = report.one_shot_consumed ? ' — consumed' : '';
-        while (btn.firstChild) btn.removeChild(btn.firstChild);
-        btn.textContent = '↯ fired: ' + (bits.join(', ') || 'no targets') + suffix;
-        btn.classList.add('btn-fire-now-flashed');
-      }
-      // Hold the flash briefly so the operator can read it before the
-      // refresh wipes the row in place.
-      setTimeout(refreshSchedules, 1500);
-    } catch (err) {
-      alert('fire-now failed: ' + err);
-      restoreBtn();
-    }
-  }
-  async function cancelScheduleAll(id) {
-    if (!confirm(`cancel schedule #${id}? this stops all future fires for every target.`)) return;
-    await postScheduleCancel(id, null);
-  }
-  async function cancelScheduleTargets(id, targets) {
-    if (!confirm(`cancel schedule #${id} for ${targets.join(', ')}? other targets keep firing.`)) return;
-    await postScheduleCancel(id, targets);
-  }
-  async function postScheduleCancel(id, targets) {
-    try {
-      const opts = {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-      };
-      if (targets) opts.body = JSON.stringify({ targets });
-      const resp = await fetch('/api/schedules/' + encodeURIComponent(id) + '/cancel', opts);
-      if (!resp.ok) {
-        const text = await resp.text().catch(() => '');
-        alert('cancel failed: http ' + resp.status + (text ? '\n\n' + text : ''));
-        return;
-      }
-      await refreshSchedules();
-    } catch (err) {
-      alert('cancel failed: ' + err);
-    }
-  }
-
   // ─── state polling ──────────────────────────────────────────────────────
   let pollTimer = null;
   // Sections whose innerHTML gets blown away on each refresh. If the