whose-turn 1.0.0-alpha.8 → 1.0.0-alpha.9

package/lib/feedback.mjs

@@ -10,7 +10,8 @@ export const RELAY_URL = 'https://6cd7q2274i726zmnyav22ar2lu0fangt.lambda-url.eu
 const PRODUCT = 'whose-turn';
 export const installOf = (appDir) => (appDir.split(sep).includes('node_modules') ? 'npm' : 'source');
 const MAX_IDS = 50;
-const STATE_NAMES = { open: 'Open', done: 'Done', dropped: 'Dropped' };
+export const NEWS_EVERY_MS = 10 * 60 * 1000;
+const STATE_NAMES = { open: 'Open', ready: 'Fixed, coming in the next release', done: 'Done', dropped: 'Dropped' };
 
 const call = async (http, url, options) => {
   try {
@@ -56,46 +57,106 @@ export const clientOf = (client) => {
 
 const environmentOf = ({ sources, install, client }) => ({ os: process.platform, osVersion: release(), arch: process.arch, node: process.version, install, sources: [...new Set(sources)].sort(), ...clientOf(client) });
 
-/** What this machine filed: the last hundred reports in <data>/reports.json. states() reads their state from the relay, detail() one report with its answers; one relay read serves both, cached for a minute. RMA-120, RMA-123. */
-export const openReports = (dataDir, { http, relayUrl }) => {
+/** What this machine filed: the last hundred reports in <data>/reports.json. states() reads their state from the relay, detail() one report with its answers; one relay read serves both, cached for a minute. When adminToken() yields a token the relay lists every user report instead, each marked `mine` when this machine filed it; no token, or a 401, leaves everything as for any user. News: a report whose state or answer count differs from <data>/reports-seen.json, which markSeen() rewrites when the sheet is read; checkNews() reads the relay at most every ten minutes. RMA-120, RMA-123, RMA-306, RMA-311. */
+export const openReports = (dataDir, { http, relayUrl, adminToken = async () => '' }) => {
   const file = join(dataDir, 'reports.json');
   let items = readJson(file, []);
+  const seenFile = join(dataDir, 'reports-seen.json');
+  let seen = readJson(seenFile, null);
   let cached = null;
-  const live = async () => {
-    if (cached && Date.now() - cached.at < 60000) {
-      return cached.value;
+  let news = false;
+  const listeners = new Set();
+  /** The admin token is looked up once per run, a miss included (the secret store can cost a process spawn); a 401 drops it so the next read looks again. */
+  let lookup = null;
+  const readAll = async () => {
+    lookup ||= adminToken();
+    const token = await lookup;
+    if (!token) {
+      return null;
     }
-    let value = {};
-    if (items.length) {
-      try {
-        const ids = items.slice(0, MAX_IDS).map((report) => report.id).join(',');
-        const answer = await http.fetchJson(`${relayUrl}?product=${PRODUCT}&ids=${encodeURIComponent(ids)}`, { useEtag: false });
-        value = Object.fromEntries((answer.issues || []).map((issue) => [issue.identifier, issue]));
-      } catch {
-        value = {};
+    try {
+      const answer = await http.fetchJson(`${relayUrl}?product=${PRODUCT}&all=1`, { useEtag: false, headers: { Authorization: `Bearer ${token}` } });
+      return answer.issues || [];
+    } catch (error) {
+      if (error.upstreamStatus === 401) {
+        lookup = null;
       }
+      return null;
+    }
+  };
+  const readOwn = async () => {
+    if (!items.length) {
+      return [];
+    }
+    try {
+      const ids = items.slice(0, MAX_IDS).map((report) => report.id).join(',');
+      return (await http.fetchJson(`${relayUrl}?product=${PRODUCT}&ids=${encodeURIComponent(ids)}`, { useEtag: false })).issues || [];
+    } catch {
+      return [];
+    }
+  };
+  const live = async (maxAge = 60000) => {
+    if (cached && Date.now() - cached.at < maxAge) {
+      return cached.value;
+    }
+    const all = await readAll();
+    const issues = all || await readOwn();
+    cached = { at: Date.now(), value: { admin: Boolean(all), issues: Object.fromEntries(issues.map((issue) => [issue.identifier, issue])), order: issues.map((issue) => issue.identifier) } };
+    return cached.value;
+  };
+  const shape = (issues) => Object.fromEntries(Object.values(issues).map((issue) => [issue.identifier, { state: issue.outcome, answers: (issue.answers || []).length }]));
+  const differs = (now) => Object.entries(now).some(([id, shown]) => !seen[id] || seen[id].state !== shown.state || seen[id].answers !== shown.answers);
+  const setNews = (value) => {
+    if (value !== news) {
+      news = value;
+      listeners.forEach((listener) => listener({ report_news: news }));
     }
-    cached = { at: Date.now(), value };
-    return value;
   };
   const merged = (report, issue) => (issue ? { ...report, title: issue.title, state: STATE_NAMES[issue.outcome] || issue.outcome, outcome: issue.outcome, changed_at: issue.updatedAt } : report);
+  const strangers = (id, issue) => merged({ id, title: issue.title, filed_at: issue.updatedAt }, issue);
   return {
     relayUrl,
     list: () => items.slice(),
+    hasNews: () => news,
+    subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); },
+    /** The background look: reuses a read younger than ten minutes, so a closed sheet costs the relay one call per ten minutes; the first look only records what is there. */
+    checkNews: async () => {
+      const now = shape((await live(NEWS_EVERY_MS)).issues);
+      if (!seen) {
+        seen = now;
+        writeJson(seenFile, seen);
+      }
+      setNews(differs(now));
+      return news;
+    },
+    /** The sheet showed these reports: remember their state and answer count, and calm the button down. A failed read keeps what was remembered. */
+    markSeen: async () => {
+      const next = { ...seen, ...shape((await live()).issues) };
+      if (JSON.stringify(next) !== JSON.stringify(seen)) {
+        seen = next;
+        writeJson(seenFile, seen);
+      }
+      setNews(false);
+    },
     add: (report) => { items = [report, ...items].slice(0, 100); cached = null; writeJson(file, items); return report; },
     states: async () => {
-      const issues = await live();
-      return items.map((report) => merged(report, issues[report.id]));
+      const { admin, issues, order } = await live();
+      if (!admin) {
+        return items.map((report) => merged(report, issues[report.id]));
+      }
+      const own = new Map(items.map((report) => [report.id, report]));
+      return order.map((id) => ({ ...(own.has(id) ? merged(own.get(id), issues[id]) : strangers(id, issues[id])), mine: own.has(id) }));
     },
     detail: async (id) => {
-      const report = items.find((item) => item.id === id);
+      const { admin, issues } = await live();
+      const issue = issues[id];
+      const report = items.find((item) => item.id === id) || (admin && issue ? strangers(id, issue) : null);
       if (!report) {
         return null;
       }
-      const issue = (await live())[id];
       const answers = (issue ? issue.answers : []).map((answer) => ({ at: answer.at, by: answer.author || '', text: answer.body })).sort((a, b) => a.at.localeCompare(b.at));
       const shown = merged(report, issue);
-      return { ...shown, answers, unanswered: Boolean(shown.outcome) && shown.outcome !== 'open' && !answers.length };
+      return { ...shown, answers, unanswered: (shown.outcome === 'done' || shown.outcome === 'dropped') && !answers.length };
     },
   };
 };

package/lib/notify.mjs

@@ -26,13 +26,8 @@ const COMMANDS = {
   ],
 };
 
-/** True under a test runner (node:test passes NODE_TEST_CONTEXT to child processes, Vitest sets VITEST) or when WHOSE_TURN_NOTIFY=off. */
-export const muted = (env = process.env) => Boolean(env.NODE_TEST_CONTEXT || env.VITEST) || env.WHOSE_TURN_NOTIFY === 'off';
-
 const launch = (file, args, env) => {
-  if (!muted()) {
-    execFile(file, args, { env: { ...process.env, ...env } }, () => {});
-  }
+  execFile(file, args, { env: { ...process.env, ...env } }, () => {});
 };
 
 /** Sends one desktop notification; `enabled: false` stays silent. */
@@ -43,5 +38,5 @@ export const notify = (title, body, { platform = process.platform, run = launch,
   }
 };
 
-/** A notify function that asks `isOn()` on every call. */
-export const notifier = (isOn) => (title, body) => notify(title, body, { enabled: isOn() });
+/** A notify function that asks `isOn()` on every call; `options` pass through to `notify`. */
+export const notifier = (isOn, options = {}) => (title, body) => notify(title, body, { ...options, enabled: isOn() });

package/lib/registry.mjs

@@ -1,9 +1,16 @@
 /** The live set of workspaces: built from the config, rebuilt on save with unchanged workspaces kept, events fanned in for the SSE stream. */
 import { ApiError } from './errors.mjs';
 
-export const createRegistry = ({ load, save, saveNotifications, build, normalise = (raw) => raw }) => {
+/** A workspace's identity for rebuilding: everything but how it is hidden, which a running workspace reads from the registry (`hiddenOf`) without a rebuild. */
+const signatureOf = (definition) => JSON.stringify({ ...definition, hidden: undefined });
+
+/** One raw workspace entry with its hide mode set, or without the key when shown. */
+export const withHidden = ({ hidden: _was, ...entry }, hidden) => (hidden ? { ...entry, hidden } : entry);
+
+export const createRegistry = ({ load, save, saveNotifications, saveSettings = /** @type {(settings: object) => unknown} */ (() => {}), build, normalise = (raw) => raw }) => {
   const listeners = new Set();
-  const registry = { workspaces: [], rawWorkspaces: [], problems: [], configFile: '', feedback: null, notifications: { desktop: true }, subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); } };
+  let hiddenModes = new Map();
+  const registry = { workspaces: [], hiddenOf: (id) => hiddenModes.get(id) || '', rawWorkspaces: [], problems: [], configFile: '', feedback: null, notifications: { desktop: true }, settings: {}, subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); } };
 
   const apply = (config, prebuilt = new Map()) => {
     const previous = new Map(registry.workspaces.map((workspace) => [workspace.id, workspace]));
@@ -11,9 +18,13 @@ export const createRegistry = ({ load, save, saveNotifications, build, normalise
     const created = [];
     const dropped = [];
     registry.workspaces = config.workspaces.map((definition) => {
-      const signature = JSON.stringify(definition);
+      const signature = signatureOf(definition);
       if (signatures.get(definition.id) === signature) {
-        return previous.get(definition.id);
+        const kept = previous.get(definition.id);
+        if (registry.hiddenOf(definition.id) && !definition.hidden) {
+          created.push(kept);
+        }
+        return kept;
       }
       let workspace;
       try {
@@ -27,9 +38,11 @@ export const createRegistry = ({ load, save, saveNotifications, build, normalise
       created.push(workspace);
       return workspace;
     }).filter(Boolean);
+    hiddenModes = new Map(config.workspaces.map((definition) => [definition.id, definition.hidden || '']));
     registry.rawWorkspaces = config.rawWorkspaces;
     registry.feedback = config.feedback;
     registry.notifications = config.notifications;
+    registry.settings = config.settings || {};
     registry.problems = [...config.problems, ...dropped];
     registry.configFile = config.configFile;
     return created;
@@ -42,7 +55,7 @@ export const createRegistry = ({ load, save, saveNotifications, build, normalise
     const prebuilt = new Map();
     try {
       for (const definition of normalise(rawWorkspaces)) {
-        const signature = JSON.stringify(definition);
+        const signature = signatureOf(definition);
         if (!known.has(signature)) {
           prebuilt.set(signature, build(definition, config));
         }
@@ -57,6 +70,15 @@ export const createRegistry = ({ load, save, saveNotifications, build, normalise
     await save(rawWorkspaces);
     return apply(load(), prebuilt);
   };
+  /** Parks, pauses or shows one workspace by rewriting its entry in the config; everything else about it stays. */
+  registry.setHidden = async (id, hidden) => {
+    await save(registry.rawWorkspaces.map((entry) => (entry.id === id ? withHidden(entry, hidden) : entry)));
+    return registry.reload();
+  };
+  registry.saveSettings = async (settings) => {
+    await saveSettings(settings);
+    registry.reload();
+  };
   registry.saveNotifications = async (notifications) => {
     await saveNotifications(notifications);
     registry.reload();

package/lib/rules.mjs

@@ -19,11 +19,11 @@ export const compileRules = (rules) => {
   };
 };
 
-export const youOr = (name, myName) => (myName && name === myName ? 'you' : name);
+const youOr = (name, myName) => (myName && name === myName ? 'you' : name);
 
 const BLANK_ROW = {
   group: 'you', whose: 'You', done: false, started: false, rank: 3, why: '', hold_url: '', hold_full: '', status_since: '', status_group: '',
-  pr: '', pr_url: '', pr_state: '', checks: '', comment: '', comment_url: '', ticket_url: '', url: '',
+  reviewers: [], pr: '', pr_url: '', pr_state: '', checks: '', comment: '', comment_url: '', ticket_url: '', url: '',
 };
 
 const row = (fields) => {
@@ -80,11 +80,18 @@ const openMentions = (comments, me, rules, cutoff) => {
   return asks;
 };
 
-const applyThen = (built, then, facts, reason) => {
+const REVIEW_MARK = { approved: '✓ ', changes: '✗ ' };
+
+/** A PR's reviewers as the user knows them: their own login reads `you`. */
+const namedReviewers = (reviewers, myName) => reviewers.map(({ name, state }) => ({ name: youOr(name, myName), state }));
+
+const applyThen = (built, then, facts, reason, reviewers) => {
   const { label, group } = WHOSE[then.whose];
+  const listed = then.whose === 'reviewer' ? reviewers : [];
   Object.assign(built, {
     group: group || built.group,
-    whose: label || built.whose,
+    whose: listed.length ? listed.map(({ name, state }) => `${REVIEW_MARK[state] || ''}${name}`).join(', ') : label || built.whose,
+    reviewers: listed,
     started: Boolean(then.started),
     rank: then.rank ?? built.rank,
     next: then.next ? fillText(then.next, facts) : built.next,
@@ -93,10 +100,10 @@ const applyThen = (built, then, facts, reason) => {
   });
 };
 
-const decided = (built, facts, rules, reason) => {
+const decided = (built, facts, rules, reason, reviewers = []) => {
   const matched = firstMatch(rules.table, facts);
   if (matched) {
-    applyThen(built, matched.then, facts, reason);
+    applyThen(built, matched.then, facts, reason, reviewers);
   }
   return built;
 };
@@ -112,7 +119,7 @@ const ticketRow = (ticket, pr, context) => {
     activity_at: [toIsoUtc(ticket.updated), pr ? pr.updated_at : ''].filter(Boolean).sort().pop(),
     ...(pr ? prCells(pr, open) : {}),
   });
-  return decided(built, facts, context.rules, reason);
+  return decided(built, facts, context.rules, reason, namedReviewers(pr?.reviewers || [], pr && context.me[pr.source]));
 };
 
 /** A failing workflow run on the default branch, decided by the table; keyed by repository, workflow and branch, and by its streak so a new breakage after a fix is a new move. */
@@ -152,7 +159,7 @@ export const turnRows = ({ tickets = [], prs = [], comments = [], asks = [], run
   const ticketKeys = new Set(tickets.map((ticket) => ticket.key));
   const mentions = openMentions(comments, me, rules, daysAgoIso(historyDays));
   const rows = tickets.map((ticket) => ticketRow(ticket, pickPr(prsByKey.get(ticket.key)), {
-    myName: me[ticket.source], rules, comments: commentsByKey.get(ticket.key) || [], mentions: mentions.get(ticket.key) || [],
+    me, myName: me[ticket.source], rules, comments: commentsByKey.get(ticket.key) || [], mentions: mentions.get(ticket.key) || [],
   }));
   for (const [key, list] of prsByKey) {
     const pr = pickPr(list);
@@ -195,7 +202,7 @@ export const feedRows = ({ activity = [], events = [], tickets = [], comments =
         text: oneline(comment.body), body: comment.body, url: comment.url,
       });
     }),
-    ...events.map((event) => feedItem({ id: eventId(event), at: event.at, source: event.source, ref: event.key, key: event.key, kind: event.kind, text: event.text, url: event.url })),
+    ...events.map((event) => feedItem({ id: eventId(event), at: event.at, source: event.source, ref: event.key, key: event.key, kind: event.kind, text: event.kind === 'reassigned' ? event.text.split(' → ').map((name) => youOr(name.trim(), me[event.source])).join(' → ') : event.text, url: event.url })),
     ...notes.map((note) => feedItem({ id: note.id, at: note.at, source: note.source, ref: note.key, key: note.key, kind: 'note', who: 'you', text: note.text, body: note.text, url: note.url })),
   ];
   const timesByKey = groupBy([...events, ...recentComments], (item) => item.key);

package/lib/table.mjs

@@ -6,6 +6,7 @@ export const WHOSE = {
   you: { label: 'You', group: 'you' },
   reviewer: { label: 'Reviewer', group: null },
   qa: { label: 'QA', group: null },
+  release: { label: 'Release', group: null },
   them: { label: null, group: null },
   hidden: { label: null, group: 'gone' },
 };

package/lib/trace.mjs

@@ -1,5 +1,5 @@
 /** The trace a row leaves in Handled when its turn passes to someone else: one phrase and the feed event behind it. */
-import { eventId, youOr } from './rules.mjs';
+import { eventId } from './rules.mjs';
 import { DAY, oneline } from './text.mjs';
 
 const lastName = (text) => String(text).split(' → ').pop().trim();
@@ -14,14 +14,14 @@ export const passedRows = (before, after) => {
 
 const mergedNow = ({ before, after }) => before.pr_state !== 'MERGED' && after.pr_state === 'MERGED';
 
-/** The newest comment on the ticket from the day before the move, as `{author, text}`, or null. */
+/** The newest comment on the ticket from the day before the move, as `{id, text}` (the feed id and a short excerpt), or null. */
 const commentBefore = (feed, key, at) => {
   const found = feed.find((item) => item.kind === 'comment' && item.key === key && Date.parse(at) - Date.parse(item.at) < DAY);
-  return found ? { author: found.who, text: oneline(found.body || found.text, 4000) } : null;
+  return found ? { id: found.id, text: oneline(found.body || found.text) } : null;
 };
 
-/** `{outcome, event, detail}` built from what moved the row, or null when no event explains it. `events` are this poll's ticket events, `feed` is newest first, `me` is your name per source. */
-export const traceOf = (pair, events, feed, me = {}) => {
+/** `{outcome, event, detail}` built from what moved the row, or null when no event explains it. `events` are this poll's ticket events, `feed` is newest first and already shows your name as you. */
+export const traceOf = (pair, events, feed) => {
   const own = events.filter((event) => event.key === pair.after.key && event.source === pair.after.source);
   const reassigned = own.find((event) => event.kind === 'reassigned');
   const status = own.find((event) => event.kind === 'status');
@@ -38,7 +38,7 @@ export const traceOf = (pair, events, feed, me = {}) => {
     return {
       outcome: comment ? `${head} · ${comment.text}` : head,
       event: eventId(reassigned),
-      detail: { what: head, assignee: names.map((name) => youOr(name.trim(), me[pair.after.source])).join(' → '), ...(status ? { status: status.text } : {}), ...(comment ? { comment } : {}) },
+      detail: { what: head, assignee: feed.find((item) => item.id === eventId(reassigned))?.text ?? reassigned.text, ...(status ? { status: status.text } : {}), ...(comment?.id ? { comment: comment.id } : {}) },
     };
   }
   return status ? { outcome: `Moved to ${lastName(status.text)}`, event: eventId(status), detail: { status: status.text } } : null;

package/lib/workspace.mjs

@@ -4,11 +4,11 @@ import { compileRules, turnRows, feedRows, myMoves, isHandled, withHandled, turn
 import { makeKeyFinder, nowIso, oneline, daysAgoIso, unionCapped, DAY } from './text.mjs';
 import { passedRows, traceOf } from './trace.mjs';
 import { buildHandOff, snapshotOf, renderHandOff, frameHandOff } from './handoff.mjs';
-import { notify as desktopNotify } from './notify.mjs';
 import { DEFAULT_LIMITS, nextFails, assess, transition } from './health.mjs';
 import { paletteFrom, derivedSeed } from './palette.mjs';
 import { CONNECTORS, connectorSummaries } from '../connectors/index.mjs';
 import { RateLimited } from './http-client.mjs';
+import { isDue } from './backoff.mjs';
 const KINDS = ['tickets', 'comments', 'prs', 'activity', 'asks', 'runs'];
 
 const stamp = (result, sourceId) => {
@@ -35,8 +35,12 @@ export const mergeLinks = (own, derived) => {
   return [...own, ...derived.filter((link) => !ownHosts.has(hostOf(link.url)))].filter((link) => !seen.has(link.url) && seen.add(link.url));
 };
 
-export const createWorkspace = (definition, { dataDir, historyDays, http, secrets, limits = () => DEFAULT_LIMITS, notify = desktopNotify }) => {
+export const createWorkspace = (definition, { dataDir, historyDays, http, secrets, limits = () => DEFAULT_LIMITS, notify, hidden = () => definition.hidden || '', unpark = /** @type {(id: string) => Promise<unknown>} */ (async () => {}) }) => {
+  if (typeof notify !== 'function') {
+    throw new TypeError('createWorkspace needs a notify function');
+  }
   const store = openStore(dataDir, definition.id);
+  const days = () => (typeof historyDays === 'function' ? historyDays() : historyDays);
   const rules = compileRules(definition.rules);
   const keyOf = makeKeyFinder(definition.key_pattern);
   const seed = definition.theme?.seed || definition.derived_seed || derivedSeed(definition.id);
@@ -48,6 +52,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   let marksVersion = 0;
   let freshAt = '';
   const startedAt = nowIso();
+  let lastPollAt = Date.parse(store.state.polled_at) || 0;
 
   const sources = () => Object.values(store.state.sources);
   const merged = () => Object.fromEntries(KINDS.map((kind) => [kind, sources().flatMap((source) => source[kind] || [])]));
@@ -66,7 +71,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     if (!derived || derived.version !== store.state.version || derived.day !== day || derived.marksVersion !== marksVersion) {
       const sources = merged();
       const state = { ...sources, events: store.state.events, notes: noteEvents() };
-      const context = { me: me(), rules, historyDays, ticketUrl };
+      const context = { me: me(), rules, historyDays: days(), ticketUrl };
       derived = { version: store.state.version, marksVersion, day, turn: turnRows(sources, context), feed: feedRows(state, context) };
     }
     return derived;
@@ -86,7 +91,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   };
 
   const emit = () => {
-    const message = { ws: definition.id, version: store.state.version, polled_at: store.state.polled_at, open_moves: myMoves(rows().turn, store.marks).length };
+    const message = { ws: definition.id, version: store.state.version, polled_at: store.state.polled_at, open_moves: myMoves(rows().turn, store.marks).length, hidden: self.hidden, returned: returned() };
     for (const listener of listeners) {
       listener(message);
     }
@@ -107,12 +112,18 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     store.saveMarks();
   };
 
-  const health = () => assess({ fails: store.state.fails, freshAt: freshAt || startedAt, now: Date.now(), limits: limits(), sourceCount: definition.connectors.length });
+  /** The health of a shown workspace; null while it is parked or paused, which is neither watched nor alerted about. */
+  const assessed = () => (self.hidden ? null : assess({ fails: store.state.fails, freshAt: freshAt || startedAt, now: Date.now(), limits: limits(), sourceCount: definition.connectors.length }));
+  const health = () => assessed() || { ok: true, stale: false, fresh_at: freshAt, failing: [], alerts: [] };
 
   let shownStreaks = '';
 
   const checkHealth = () => {
-    const { alerts } = health();
+    const watched = assessed();
+    if (!watched) {
+      return;
+    }
+    const { alerts } = watched;
     const { raised, recovered, alerted } = transition(store.marks.health_alerted, alerts);
     const streaks = alerts.filter((alert) => alert.id.startsWith('failing:')).map((alert) => alert.text).join('\n');
     if (!raised.length && !recovered.length) {
@@ -142,7 +153,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     }
     caches[entry.id] = caches[entry.id] || store.loadCache(entry.id);
     try {
-      const result = await connector.poll({ settings: entry, http, secrets, cache: caches[entry.id], sinceIso: daysAgoIso(historyDays), historyDays, keyOf });
+      const result = await connector.poll({ settings: entry, http, secrets, cache: caches[entry.id], sinceIso: daysAgoIso(days()), historyDays: days(), keyOf });
       const errors = Object.fromEntries(Object.entries(result.errors || {}).map(([part, message]) => [`${entry.id}.${part}`, message]));
       return { data: stamp(result, entry.id), errors };
     } catch (error) {
@@ -157,12 +168,16 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   };
 
   const poll = async () => {
+    lastPollAt = Date.now();
+    const checkedBefore = Boolean(store.state.polled_at);
     expireHandled();
     const outcomes = await Promise.all(definition.connectors.map(pollSource));
     const state = store.state;
     const errors = {};
     const ticketsBefore = merged().tickets;
     const turnBefore = rows().turn;
+    const parked = self.hidden === 'parked' && checkedBefore;
+    const movesBefore = parked ? new Set(myMoves(turnBefore, store.marks).map((move) => move.row_id)) : null;
     definition.connectors.forEach((entry, index) => {
       const outcome = outcomes[index];
       Object.assign(errors, outcome.errors);
@@ -202,11 +217,39 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     if (outcomes.some((outcome) => outcome.data)) {
       saveCaches();
     }
+    if (parked && outcomes.some((outcome) => outcome.data)) {
+      await comeBack(myMoves(rows().turn, store.marks).filter((move) => !movesBefore.has(move.row_id)));
+    }
     checkHealth();
     emit();
     return { errors, rateLimited: outcomes.some((outcome) => outcome.rateLimited) };
   };
 
+  /** A parked workspace whose check found new moves for you goes back into the rail, with a feed line that says why. */
+  const comeBack = async (arrived) => {
+    if (!arrived.length) {
+      return;
+    }
+    const [first] = arrived;
+    const text = arrived.length === 1 ? 'Back in the rail: this needs you' : `Back in the rail: ${arrived.length} items need you`;
+    store.state.events = [{ at: nowIso(), source: first.source, key: first.key, kind: 'returned', text, url: first.ticket_url || first.url }, ...store.state.events].slice(0, 500);
+    store.state.version += 1;
+    store.saveState();
+    await unpark(definition.id).catch(() => {});
+  };
+
+  /** The feed items you have not seen: not in the seen marks and newer than the base. */
+  const unseen = (items) => {
+    const seen = new Set(store.marks.seen);
+    return items.filter((item) => !seen.has(item.id) && new Date(item.at).getTime() > store.marks.base);
+  };
+
+  /** Whether the feed holds a line about the workspace coming back that you have not seen yet: the rail's dot. */
+  const returned = () => {
+    const lines = rows().feed.filter((item) => item.kind === 'returned');
+    return lines.length > 0 && unseen(lines).length > 0;
+  };
+
   const rowRef = (row) => ({ key: row.key, source: row.source, url: row.ticket_url || row.url });
 
   /** Adds the auto Handled mark to rows whose turn passed on in this poll and drops it from rows whose turn came back. */
@@ -216,7 +259,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     let changed = false;
     let notesMoved = false;
     for (const pair of passedRows(turnBefore, turn)) {
-      const trace = traceOf(pair, fresh, feed, me());
+      const trace = traceOf(pair, fresh, feed);
       if (trace) {
         const rowId = pair.after.row_id;
         notesMoved ||= Boolean(info[rowId]?.note);
@@ -256,10 +299,10 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   const identity = () => ({
     id: definition.id, name: definition.name, key_pattern: definition.key_pattern, links: quickLinks(),
     connectors: connectorSummaries(definition.connectors),
-    open_moves: myMoves(rows().turn, store.marks).length,
+    open_moves: myMoves(rows().turn, store.marks).length, hidden: self.hidden,
   });
 
-  const describe = () => ({ ...identity(), theme, theme_seed: seed, failing_sources: Object.keys(store.state.errors || {}).length });
+  const describe = () => ({ ...identity(), theme, theme_seed: seed, backdrop: definition.theme?.backdrop !== false, failing_sources: Object.keys(store.state.errors || {}).length, returned: returned() });
 
   const todosWithLinks = () => store.todos.map((todo) => ({ ...todo, ticket_url: todo.key ? ticketUrl(todo.key) : '' }));
 
@@ -289,9 +332,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   const handOffSnapshot = (kind, ref) => snapshotOf(kind, ref, handOffSource());
 
   const summary = () => {
-    const seen = new Set(store.marks.seen);
-    const unread = rows().feed.filter((item) => !seen.has(item.id) && new Date(item.at).getTime() > store.marks.base).length;
-    return { ...identity(), moves: myMoves(rows().turn, store.marks), new_events: unread, todos: todosWithLinks().filter((todo) => !todo.done), polled_at: store.state.polled_at, errors: store.state.errors, health: health() };
+    return { ...identity(), moves: myMoves(rows().turn, store.marks), new_events: unseen(rows().feed).length, todos: todosWithLinks().filter((todo) => !todo.done), polled_at: store.state.polled_at, errors: store.state.errors, health: health() };
   };
 
   const noteOn = (rowId, text) => {
@@ -365,8 +406,15 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     emit();
   };
 
-  return {
-    id: definition.id, name: definition.name, sourceTypes: [...new Set(definition.connectors.map((entry) => entry.type))], rulesTable: rules.table, store, poll, snapshot, summary, describe, checkHealth, handOff, handOffBody, handOffText, handOffSnapshot, updateMarks, addTodo, changeTodo, saveTodos,
+  /** Polls when the round is due for this workspace: every round when shown, every 15 minutes when parked, never when paused. */
+  const pollIfDue = () => (isDue(self.hidden, lastPollAt, Date.now()) ? poll() : Promise.resolve({ errors: {}, rateLimited: false }));
+
+  const self = {
+    get hidden() {
+      return hidden();
+    },
+    id: definition.id, name: definition.name, sourceTypes: [...new Set(definition.connectors.map((entry) => entry.type))], rulesTable: rules.table, store, poll, pollIfDue, snapshot, summary, describe, checkHealth, handOff, handOffBody, handOffText, handOffSnapshot, updateMarks, addTodo, changeTodo, saveTodos,
     subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); },
   };
+  return self;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whose-turn",
-  "version": "1.0.0-alpha.8",
+  "version": "1.0.0-alpha.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -56,6 +56,7 @@
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-vue": "10.11.1",
     "happy-dom": "21.0.4",
+    "motion-v": "2.9.0",
     "postcss-html": "2.0.0",
     "prettier": "3.9.10",
     "stylelint": "17.16.0",

package/server.mjs

@@ -3,14 +3,14 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { loadConfig, saveWorkspaces, saveNotifications, normaliseWorkspaces } from './lib/config.mjs';
+import { loadConfig, saveWorkspaces, saveNotifications, saveSettings, normaliseWorkspaces } from './lib/config.mjs';
 import { createHttpClient } from './lib/http-client.mjs';
 import { nextDelay } from './lib/backoff.mjs';
 import { createSecrets } from './lib/secrets.mjs';
 import { createWorkspace } from './lib/workspace.mjs';
 import { createRegistry } from './lib/registry.mjs';
 import { openInbox } from './lib/inbox.mjs';
-import { openReports, RELAY_URL } from './lib/feedback.mjs';
+import { openReports, RELAY_URL, NEWS_EVERY_MS } from './lib/feedback.mjs';
 import { startApi } from './lib/api.mjs';
 import { notifier } from './lib/notify.mjs';
 import { loadChangelog } from './lib/changelog.mjs';
@@ -21,10 +21,10 @@ const http = createHttpClient();
 const first = loadConfig();
 const secrets = createSecrets(first.dataDir);
 const inbox = openInbox(first.dataDir);
-const reports = openReports(first.dataDir, { http, relayUrl: process.env.WHOSE_TURN_FEEDBACK_URL || RELAY_URL });
+const reports = openReports(first.dataDir, { http, relayUrl: process.env.WHOSE_TURN_FEEDBACK_URL || RELAY_URL, adminToken: () => secrets.get('whose-turn-feedback-admin', 'relay') });
 const { version } = JSON.parse(readFileSync(join(appDir, 'package.json'), 'utf8'));
 let server;
-const notify = notifier(() => registry.notifications.desktop);
+const notify = notifier(() => process.env.WHOSE_TURN_NOTIFY !== 'off' && registry.notifications.desktop);
 const updater = createUpdater({
   http,
   dataDir: first.dataDir,
@@ -36,6 +36,7 @@ const updater = createUpdater({
   restart: () => restartServer({ server, root: appDir, dataDir: first.dataDir }),
 });
 let pollSeconds = first.pollSeconds;
+let historyDays = first.historyDays;
 /** @type {{ stale_minutes: number, failing_polls: number }} */
 let healthLimits = /** @type {any} */ (first.health);
 
@@ -43,13 +44,15 @@ const registry = createRegistry({
   load: () => {
     const config = loadConfig();
     pollSeconds = config.pollSeconds;
+    historyDays = config.historyDays;
     healthLimits = /** @type {any} */ (config.health);
     return config;
   },
   save: (rawWorkspaces) => saveWorkspaces(first.configFile, rawWorkspaces),
   saveNotifications: (notifications) => saveNotifications(first.configFile, notifications),
+  saveSettings: (settings) => saveSettings(first.configFile, settings),
   normalise: (rawWorkspaces) => normaliseWorkspaces(rawWorkspaces).workspaces,
-  build: (definition, config) => createWorkspace(definition, { dataDir: config.dataDir, historyDays: config.historyDays, http, secrets, limits: () => healthLimits, notify }),
+  build: (definition, config) => createWorkspace(definition, { dataDir: config.dataDir, historyDays: () => historyDays, http, secrets, limits: () => healthLimits, notify, hidden: () => registry.hiddenOf(definition.id), unpark: (id) => registry.setHidden(id, '') }),
 });
 
 let wake = null;
@@ -62,7 +65,7 @@ const sleep = (seconds) => new Promise((resolve) => {
 const pollLoop = async () => {
   let delay = pollSeconds;
   for (;;) {
-    const outcomes = await Promise.all(registry.workspaces.map((workspace) => workspace.poll()));
+    const outcomes = await Promise.all(registry.workspaces.map((workspace) => workspace.pollIfDue()));
     delay = nextDelay(outcomes, delay, pollSeconds);
     await sleep(delay);
   }
@@ -70,7 +73,7 @@ const pollLoop = async () => {
 
 const saveConfig = async (rawWorkspaces) => {
   const created = await registry.save(rawWorkspaces);
-  await Promise.all(created.map((workspace) => workspace.poll()));
+  await Promise.all(created.map((workspace) => workspace.pollIfDue()));
 };
 
 try {
@@ -85,6 +88,10 @@ for (const problem of registry.problems) {
 }
 pollLoop();
 updater.start();
+const FIRST_NEWS_MS = 30000;
+const checkReports = () => reports.checkNews().catch(() => {});
+setTimeout(checkReports, FIRST_NEWS_MS).unref();
+setInterval(checkReports, NEWS_EVERY_MS).unref();
 
 const HEALTH_TICK = 30000;
 let lastTick = Date.now();