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

package/lib/config.mjs

@@ -2,11 +2,13 @@
 import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
+import { isObject } from './text.mjs';
 import { isHex, derivedSeeds } from './palette.mjs';
 import { statusGroups } from './facts.mjs';
 import { tableProblems, tableWarnings } from './table.mjs';
 import { DEFAULT_LIMITS } from './health.mjs';
 import { CONNECTORS } from '../connectors/index.mjs';
+import { HIDDEN_MODES } from './backoff.mjs';
 
 export const DEFAULT_RULES = {
   release_branch_prefix: 'release/',
@@ -18,6 +20,7 @@ export const DEFAULT_RULES = {
     passed: ['passed'],
     code_review: ['code review', 'in review'],
     qa: ['ready for qa', 'in qa', 'testing'],
+    release: ['ready for release', 'ready to release', 'awaiting release'],
     on_hold: ['on hold', 'blocked'],
     backlog: ['backlog'],
   },
@@ -39,6 +42,7 @@ export const WORKSPACE_FIELDS = {
   theme: [
     { key: 'seed', label: 'Seed colour', hint: 'the scheme is derived from it; empty derives one from the workspace id', colour: true },
     { key: 'accent', label: 'Accent colour', hint: 'optional second hue', colour: true },
+    { key: 'backdrop', label: 'Backdrop animal', hint: 'draw the dotted animal behind the window', boolean: true, default: true },
   ],
   rules: [
     { key: 'approved_next', label: 'Next step when the PR is approved', hint: 'shown when a PR under review is approved' },
@@ -53,11 +57,37 @@ export const WORKSPACE_FIELDS = {
     { key: 'code_review', label: 'Review statuses', list: true },
     { key: 'qa', label: 'Testing statuses', list: true },
     { key: 'passed', label: 'Passed statuses', list: true },
+    { key: 'release', label: 'Release statuses', list: true },
     { key: 'on_hold', label: 'On hold statuses', list: true },
     { key: 'backlog', label: 'Backlog statuses', list: true },
   ],
 };
 
+/** The monitor-wide numbers the settings sheet and Claude may edit, with their defaults: how often to poll, how far back the feed reaches, and when a health alert fires. */
+export const GLOBAL_SETTINGS = {
+  poll_seconds: { fallback: 60, label: 'Poll every (seconds)', hint: 'how often every workspace is polled' },
+  history_days: { fallback: 14, label: 'History (days)', hint: 'how far back the feed and the mentions reach', whole: true },
+  stale_minutes: { fallback: DEFAULT_LIMITS.stale_minutes, label: 'Stale after (minutes)', hint: 'alert when no source has answered for this long' },
+  failing_polls: { fallback: DEFAULT_LIMITS.failing_polls, label: 'Failing polls in a row', hint: 'alert when one source fails this many polls in a row', whole: true },
+};
+
+/** Field violations for a `settings` object: unknown keys, and values that are not positive numbers (whole numbers where the key says so). */
+export const settingsViolations = (settings) => {
+  if (!isObject(settings)) {
+    return [{ field: 'settings', description: 'settings must be an object.' }];
+  }
+  return Object.entries(settings).flatMap(([key, value]) => {
+    const spec = GLOBAL_SETTINGS[key];
+    if (!spec) {
+      return [{ field: `settings.${key}`, description: `${key} is not a setting; the settings are ${Object.keys(GLOBAL_SETTINGS).join(', ')}.` }];
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0 || (spec.whole && !Number.isInteger(value))) {
+      return [{ field: `settings.${key}`, description: `${key} must be a positive ${spec.whole ? 'whole ' : ''}number.` }];
+    }
+    return [];
+  });
+};
+
 /** The per-platform directory that holds config.json and the state, unless WHOSE_TURN_DATA overrides it. */
 export const defaultDataDir = () => {
   if (process.platform === 'darwin') {
@@ -115,8 +145,6 @@ const legacyWorkspace = (raw) => {
   return { id: 'default', name: 'Default', connectors, rules: raw.rules, key_pattern: raw.jira?.key_pattern };
 };
 
-const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
 const connectorEntries = (connectors) => {
   const list = Array.isArray(connectors) ? connectors : Object.entries(connectors || {}).map(([type, settings]) => ({ type, ...settings }));
   return list.filter(isObject).map((entry) => ({ ...entry, id: String(entry.id || entry.type) }));
@@ -126,14 +154,21 @@ const normaliseTheme = (theme, problems, workspaceId) => {
   if (!theme) {
     return null;
   }
+  const backdrop = theme.backdrop === false ? { backdrop: false } : {};
+  if (theme.backdrop !== undefined && typeof theme.backdrop !== 'boolean') {
+    problems.push(`Workspace "${workspaceId}": theme.backdrop must be true or false; the backdrop stays on.`);
+  }
+  if (theme.seed === undefined && theme.accent === undefined) {
+    return Object.keys(backdrop).length ? backdrop : null;
+  }
   if (!isHex(theme.seed)) {
     problems.push(`Workspace "${workspaceId}": theme.seed must be a hex colour like #3d7a5c; the theme is ignored.`);
-    return null;
+    return Object.keys(backdrop).length ? backdrop : null;
   }
   if (theme.accent !== undefined && !isHex(theme.accent)) {
     problems.push(`Workspace "${workspaceId}": theme.accent must be a hex colour like #c27a2c; the accent is ignored.`);
   }
-  return { seed: theme.seed.toLowerCase(), ...(isHex(theme.accent) ? { accent: theme.accent.toLowerCase() } : {}) };
+  return { seed: theme.seed.toLowerCase(), ...(isHex(theme.accent) ? { accent: theme.accent.toLowerCase() } : {}), ...backdrop };
 };
 
 const normaliseLinks = (links) => (Array.isArray(links) ? links : []).map((entry) => {
@@ -159,6 +194,9 @@ const fieldProblems = (workspace, id, index) => {
       problems.push(violation(`${at}.key_pattern`, `${where}: key_pattern is not a valid regular expression: ${error.message}`));
     }
   }
+  if (workspace.hidden !== undefined && !HIDDEN_MODES.includes(workspace.hidden)) {
+    problems.push(violation(`${at}.hidden`, `${where}: hidden must be one of ${HIDDEN_MODES.join(', ')}, or left out.`));
+  }
   const rules = workspace.rules || {};
   const backlogChoices = WORKSPACE_FIELDS.rules.find((field) => field.key === 'backlog_rows').choices;
   if (rules.backlog_rows !== undefined && !backlogChoices.includes(rules.backlog_rows)) {
@@ -210,7 +248,7 @@ const normaliseWorkspace = (workspace, index, problems, warnings) => {
   if (tableNotes.length) {
     warnings[id] = tableNotes;
   }
-  return {
+  return /** @type {any} */ ({
     id,
     links: normaliseLinks(workspace.links),
     name: String(workspace.name || workspace.id || `Workspace ${index + 1}`),
@@ -218,7 +256,8 @@ const normaliseWorkspace = (workspace, index, problems, warnings) => {
     rules,
     key_pattern: workspace.key_pattern || DEFAULT_KEY_PATTERN,
     theme: normaliseTheme(workspace.theme, problems, id),
-  };
+    ...(HIDDEN_MODES.includes(workspace.hidden) ? { hidden: workspace.hidden } : {}),
+  });
 };
 
 export const loadConfig = (env = process.env) => {
@@ -227,7 +266,7 @@ export const loadConfig = (env = process.env) => {
   const raw = readJson(configFile);
   const problems = [];
   if (raw === null) {
-    problems.push(`No workspace config yet: open Settings (the gear) to add a source. It will be written to ${configFile}.`);
+    problems.push(`No workspace config yet: add a source in the workspace settings (top right of the workspace). It will be written to ${configFile}.`);
   } else if (raw.parse_error) {
     problems.push(`Cannot parse ${configFile}: ${raw.parse_error}`);
   }
@@ -236,14 +275,19 @@ export const loadConfig = (env = process.env) => {
   const { workspaces: normalised, problems: shapeProblems, warnings } = normaliseWorkspaces(rawWorkspaces);
   const warningLines = Object.entries(warnings).flatMap(([id, lines]) => lines.map((line) => `Workspace "${id}": ${line}.`));
   const workspaces = normalised.filter((workspace) => WORKSPACE_ID.test(workspace.id));
+  const health = normaliseHealth(source, problems);
+  const pollSeconds = Number(source.poll_seconds || GLOBAL_SETTINGS.poll_seconds.fallback);
+  const historyDays = Number(source.history_days || GLOBAL_SETTINGS.history_days.fallback);
   return {
     dataDir,
     configFile,
     port: resolvePort(dataDir, env),
-    pollSeconds: Number(source.poll_seconds || 60),
-    historyDays: Number(source.history_days || 14),
-    health: normaliseHealth(source, problems),
-    feedback: source.feedback && typeof source.feedback === 'object' ? source.feedback : null,
+    pollSeconds,
+    historyDays,
+    health,
+    settings: { poll_seconds: pollSeconds, history_days: historyDays, ...health },
+    feedback: withoutRetiredFeedbackKeys(source.feedback),
+    notifications: normaliseNotifications(source.notifications, problems),
     workspaces,
     rawWorkspaces,
     problems: [...problems, ...shapeProblems, ...warningLines],
@@ -259,6 +303,20 @@ const normaliseHealth = (source, problems) => Object.fromEntries(Object.entries(
   return [key, value];
 }));
 
+/** The boolean `desktop` of a notifications block, or undefined. */
+export const desktopOf = (notifications) => (isObject(notifications) && typeof notifications.desktop === 'boolean' ? notifications.desktop : undefined);
+
+const normaliseNotifications = (notifications, problems) => {
+  if (notifications === undefined) {
+    return { desktop: true };
+  }
+  const desktop = desktopOf(notifications);
+  if (desktop === undefined) {
+    problems.push('notifications.desktop must be true or false; desktop notifications stay on.');
+  }
+  return { desktop: desktop ?? true };
+};
+
 /** Field violations for entries that are not objects: a workspace, or a connector in a workspace's connectors list. Checked before normalising, which assumes objects. */
 export const entryShapeViolations = (rawWorkspaces) => (Array.isArray(rawWorkspaces) ? rawWorkspaces : []).flatMap((workspace, index) => {
   if (!isObject(workspace)) {
@@ -293,18 +351,47 @@ export const normaliseWorkspaces = (rawWorkspaces) => {
       problems.push(`Workspace "${workspace.id}" has two connectors with the same id; give each an "id".`);
     }
   }
+  if (workspaces.length && workspaces.every((workspace) => workspace.hidden)) {
+    problems.push('Keep at least one workspace in the rail: parked and paused workspaces are out of it.');
+  }
   const violations = problems.map(toViolation);
   return { workspaces, problems: violations.map((entry) => entry.description), violations, warnings };
 };
 
-/** Writes the workspace list into the config file, keeping its other top-level keys and dropping the flat pre-workspace keys; the previous file is kept as config.json.bak. */
-export const saveWorkspaces = (configFile, rawWorkspaces) => {
+const RETIRED_FEEDBACK_KEYS = ['workspace', 'team', 'project', 'token_service', 'assign'];
+
+const withoutRetiredFeedbackKeys = (feedback) => (isObject(feedback) ? Object.fromEntries(Object.entries(feedback).filter(([key]) => !RETIRED_FEEDBACK_KEYS.includes(key))) : {});
+
+const storedConfig = (configFile) => {
   const current = readJson(configFile);
-  const source = current && !current.parse_error ? current : {};
+  return current && !current.parse_error ? current : {};
+};
+
+/** Writes `patch` over the config file's top-level keys and leaves every other key as it is; an unparsable file is replaced, the previous one stays as config.json.bak. */
+const mergeIntoConfig = (configFile, patch) => writeConfig(configFile, { ...storedConfig(configFile), ...patch });
+
+/** Writes the workspace list into the config file; the previous file stays as config.json.bak. */
+export const saveWorkspaces = (configFile, rawWorkspaces) => {
+  const source = storedConfig(configFile);
   delete source.github;
   delete source.jira;
   delete source.rules;
-  const next = { ...source, workspaces: rawWorkspaces };
+  const feedback = withoutRetiredFeedbackKeys(source.feedback);
+  if (Object.keys(feedback).length) {
+    source.feedback = feedback;
+  } else {
+    delete source.feedback;
+  }
+  writeConfig(configFile, { ...source, workspaces: rawWorkspaces });
+};
+
+/** Writes the validated notifications block into the config file. */
+export const saveNotifications = (configFile, notifications) => mergeIntoConfig(configFile, { notifications });
+
+/** Writes the validated monitor-wide numbers (poll_seconds, history_days, stale_minutes, failing_polls) into the config file, leaving every other key as it is. */
+export const saveSettings = (configFile, settings) => mergeIntoConfig(configFile, settings);
+
+const writeConfig = (configFile, next) => {
   mkdirSync(dirname(configFile), { recursive: true });
   if (existsSync(configFile)) {
     writeFileSync(`${configFile}.bak.tmp`, readFileSync(configFile));

package/lib/default-table.mjs

@@ -44,6 +44,7 @@ export const defaultTable = (rules) => [
   },
   { when: { 'ticket.status': 'code_review' }, then: { whose: 'reviewer', next: 'Code review' } },
   { when: { 'ticket.status': 'qa' }, then: { whose: 'them', next: 'Testing' } },
+  { when: { 'ticket.status': 'release' }, then: { whose: 'release', next: 'the next release' } },
   { when: { 'ticket.status': 'on_hold', 'ticket.hold_reason': { present: true } }, then: { whose: 'them', next: 'On hold: {ticket.hold_reason}', hold: true } },
   { when: { 'ticket.status': 'on_hold' }, then: { whose: 'them', next: 'On hold' } },
   {

package/lib/errors.mjs

@@ -9,8 +9,7 @@ const REASONS = {
   INVALID_BODY: { code: 400, status: 'INVALID_ARGUMENT', message: 'The request body is not valid JSON.' },
   INVALID_ARGUMENT: { code: 400, status: 'INVALID_ARGUMENT', message: 'A required value is missing or has the wrong shape.' },
   INVALID_CONFIG: { code: 400, status: 'INVALID_ARGUMENT', message: 'The workspace list has problems; nothing was saved.' },
-  NO_WORKSPACE: { code: 412, status: 'FAILED_PRECONDITION', message: 'No workspace is configured; open Settings to add one.' },
-  NOT_CONFIGURED: { code: 412, status: 'FAILED_PRECONDITION', message: 'Feedback is not configured: set feedback.workspace, feedback.team and feedback.project in the config.' },
+  NO_WORKSPACE: { code: 412, status: 'FAILED_PRECONDITION', message: 'No workspace is configured; add one with + in the rail.' },
   UPSTREAM_FAILED: { code: 502, status: 'UNAVAILABLE', message: 'The tracker did not answer; try again in a minute.' },
   RATE_LIMITED: { code: 429, status: 'RESOURCE_EXHAUSTED', message: 'The source is rate-limited; try again later.' },
   OPEN_TOO_SOON: { code: 429, status: 'RESOURCE_EXHAUSTED', message: 'The window was just opened; wait a few seconds before opening it again.' },

package/lib/facts.mjs

@@ -4,7 +4,7 @@ import { DAY, oneline, newestFirst } from './text.mjs';
 export const shortDate = (iso) => new Date(iso).toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
 
 const CATEGORY_GROUPS = { new: 'todo', indeterminate: 'in_progress', done: 'done' };
-const CHAIN_GROUPS = ['backlog', 'passed', 'code_review', 'qa', 'on_hold'];
+const CHAIN_GROUPS = ['backlog', 'passed', 'code_review', 'qa', 'release', 'on_hold'];
 
 /** The closed fact dictionary a table row may test or quote, each with its plain words.
  * Rules: docs/mechanisms/rules-table.md, Facts. */

package/lib/feedback.mjs

@@ -1,147 +1,176 @@
-/** Files a bug or an improvement about the monitor itself into its own Linear project, with the context the sender attaches. RMA-104. */
-import { join } from 'node:path';
+/** Files a bug or an improvement about the monitor itself through the maintainer's relay, and reads back what became of it. A report carries the kind, the title, the text, the version and a technical environment built here, nothing else. RMA-104, RMA-280, RMA-291. */
+import { release } from 'node:os';
+import { join, sep } from 'node:path';
 import { readJson, writeJson } from './store.mjs';
-import { nowIso } from './text.mjs';
+import { isObject, nowIso } from './text.mjs';
 import { ApiError } from './errors.mjs';
 import { RateLimited } from './http-client.mjs';
-import { linearQuery } from './linear-api.mjs';
 
-export const DEFAULT_SERVICE = 'whose-turn-feedback';
-const KINDS = { bug: 'Bug', improvement: 'Improvement', idea: 'Feature' };
+export const RELAY_URL = 'https://6cd7q2274i726zmnyav22ar2lu0fangt.lambda-url.eu-central-1.on.aws/';
+const PRODUCT = 'whose-turn';
+export const installOf = (appDir) => (appDir.split(sep).includes('node_modules') ? 'npm' : 'source');
+const MAX_IDS = 50;
+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 LOOKUP = `
-query Lookup($team: String!, $project: String!) {
-  viewer { id }
-  teams(filter: { key: { eq: $team } }) { nodes { id key labels { nodes { id name } } } }
-  projects(filter: { name: { eqIgnoreCase: $project } }) { nodes { id name } }
-}`;
-
-const STATES = `
-query States($team: String!, $numbers: [Float!]!) {
-  issues(first: 100, filter: { team: { key: { eq: $team } }, number: { in: $numbers } }) { nodes { identifier title url updatedAt state { name type } } }
-}`;
-
-const ANSWERS = `
-query Answers($id: String!) {
-  issue(id: $id) { comments(first: 50) { nodes { body createdAt user { name } } } }
-}`;
-
-const CREATE = `
-mutation Create($input: IssueCreateInput!) {
-  issueCreate(input: $input) { success issue { id identifier number url title } }
-}`;
-
-/** A Linear call; a rate limit, a failing answer or a GraphQL error comes out as the matching ApiError, the raw text only in its debug field. */
-const call = async (http, key, query, variables) => {
+const call = async (http, url, options) => {
   try {
-    return await linearQuery(http, key, query, variables);
+    return await http.fetchJson(url, { ...options, useEtag: false });
   } catch (error) {
-    const failure = error instanceof RateLimited ? new ApiError('RATE_LIMITED') : new ApiError('UPSTREAM_FAILED', error.upstreamStatus ? { upstream_status: error.upstreamStatus } : {});
+    const failure = error instanceof RateLimited
+      ? new ApiError('RATE_LIMITED')
+      : error.upstreamStatus === 400
+        ? new ApiError('INVALID_ARGUMENT', { detail: 'the tracker refused the report' })
+        : new ApiError('UPSTREAM_FAILED', error.upstreamStatus ? { upstream_status: error.upstreamStatus } : {});
     failure.debug = String(error.message);
     throw failure;
   }
 };
 
-const describe = ({ kind, body, context, from }) => [
-  body ? body.trim() : '',
-  '',
-  '---',
-  `Filed from Whose Turn by ${from || 'the window'} on ${nowIso()} as ${KINDS[kind] || kind}.`,
-  ...(context ? ['', typeof context === 'string' ? context.slice(0, 6000) : `\`\`\`json\n${JSON.stringify(context, null, 1).slice(0, 6000)}\n\`\`\``] : []),
-].join('\n');
+const isSize = (value) => Number.isInteger(value) && value >= 1 && value <= 20000;
+const BROWSERS = ['Chrome', 'Edge', 'Safari', 'Firefox', 'Opera', 'Brave', 'Arc', 'Chromium', 'Other'];
+const exactly = (value, keys) => isObject(value) && Object.keys(value).sort().join() === keys;
 
-const serviceOf = (settings) => settings.token_service || DEFAULT_SERVICE;
-const keyFor = async (settings, secrets) => (settings && settings.workspace ? secrets.get(serviceOf(settings), settings.workspace) : '');
-
-/** Which way an issue went: open, done, or dropped (canceled); the window and the report page see no Linear vocabulary. */
-const outcomeOf = (state) => ({ completed: 'done', canceled: 'dropped' }[state.type] || 'open');
+const CLIENT_FIELDS = {
+  browser: (value) => (exactly(value, 'name,version') && BROWSERS.includes(value.name) && typeof value.version === 'string' && /^\d{1,6}$/.test(value.version) ? { name: value.name, version: value.version } : undefined),
+  display: (value) => {
+    const sane = exactly(value, 'height,scale,viewport,width') && isSize(value.width) && isSize(value.height) && typeof value.scale === 'number' && value.scale >= 0.5 && value.scale <= 8 && Array.isArray(value.viewport) && value.viewport.length === 2 && value.viewport.every(isSize);
+    return sane ? { width: value.width, height: value.height, scale: Math.round(value.scale * 100) / 100, viewport: [...value.viewport] } : undefined;
+  },
+  locale: (value) => (typeof value === 'string' && value.length <= 35 && /^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$/.test(value) ? value : undefined),
+  timezone: (value) => (typeof value === 'string' && value.length <= 64 && /^[A-Za-z][A-Za-z0-9_+-]*(\/[A-Za-z0-9_+-]+)*$/.test(value) ? value : undefined),
+  theme: (value) => (value === 'light' || value === 'dark' ? value : undefined),
+  mode: (value) => (value === 'app' || value === 'tab' ? value : undefined),
+};
 
-const askLinear = async ({ settings, secrets, http }, query, variables) => {
-  const key = await keyFor(settings, secrets);
-  if (!key || !settings.team) {
-    return null;
-  }
-  try {
-    return await call(http, key, query, variables);
-  } catch {
-    return null;
+/** What the window reported about itself, keeping only the fields that are exactly the agreed shape; a bad or missing one is left out, never an error. RMA-291. */
+export const clientOf = (client) => {
+  const clean = {};
+  for (const [key, check] of Object.entries(CLIENT_FIELDS)) {
+    const value = isObject(client) ? check(client[key]) : undefined;
+    if (value !== undefined) {
+      clean[key] = value;
+    }
   }
+  return clean;
 };
 
-/** What this machine filed: the last hundred issues in <data>/reports.json. states() reads their Linear state, detail() one issue's comments as answers; both cached for a minute. RMA-120, RMA-123. */
-export const openReports = (dataDir) => {
+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. 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 cache = new Map();
-  const remembered = async (name, read) => {
-    const hit = cache.get(name);
-    if (hit && Date.now() - hit.at < 60000) {
-      return hit.value;
+  const seenFile = join(dataDir, 'reports-seen.json');
+  let seen = readJson(seenFile, null);
+  let cached = null;
+  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;
+    }
+    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 value = await read();
-    cache.set(name, { at: Date.now(), value });
-    return value;
   };
-  const states = (deps) => remembered('states', async () => {
-    const data = items.length ? await askLinear(deps, STATES, { team: deps.settings.team, numbers: items.map((report) => report.number).filter(Number.isFinite) }) : null;
-    const live = Object.fromEntries((data ? data.issues.nodes : []).map((node) => [node.identifier, node]));
-    return items.map((report) => {
-      const issue = live[report.id];
-      return issue ? { ...report, title: issue.title, state: issue.state.name, outcome: outcomeOf(issue.state), changed_at: issue.updatedAt } : report;
-    });
-  });
+  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 }));
+    }
+  };
+  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(),
-    add: (report) => { items = [report, ...items].slice(0, 100); cache.clear(); writeJson(file, items); return report; },
-    states,
-    detail: async (deps, id) => {
-      const report = (await states(deps)).find((item) => item.id === id);
+    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 { 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 { 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 answers = await remembered(`answers:${id}`, async () => {
-        const data = await askLinear(deps, ANSWERS, { id });
-        return (data && data.issue ? data.issue.comments.nodes : []).map((comment) => ({ at: comment.createdAt, by: comment.user ? comment.user.name : '', text: comment.body })).sort((a, b) => a.at.localeCompare(b.at));
-      });
-      return { ...report, answers, unanswered: Boolean(report.outcome) && report.outcome !== 'open' && !answers.length };
+      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: (shown.outcome === 'done' || shown.outcome === 'dropped') && !answers.length };
     },
   };
 };
 
-/** True when the config names the Linear workspace, team and project reports go to. */
-export const isConfigured = (settings) => Boolean(settings && settings.workspace && settings.team && settings.project);
-
-export const createFeedback = async ({ settings, secrets, http, cache, reports }, { kind = 'improvement', title, body = '', context = null, from = '' }) => {
-  if (!isConfigured(settings)) {
-    throw new ApiError('NOT_CONFIGURED');
-  }
-  const cleanTitle = String(title || '').trim().slice(0, 200);
+/** Files a report through the relay; returns {identifier, url, title}. */
+export const createFeedback = async ({ http, relayUrl, reports, version, sources = [], install = 'source', client = null }, { kind = 'improvement', title, body = '' }) => {
+  const cleanTitle = String(title || '').trim().slice(0, 140);
   if (!cleanTitle) {
     throw new ApiError('INVALID_ARGUMENT', { detail: 'a title is required' }, [{ field: 'title', description: 'A report needs a title.' }]);
   }
-  const key = await keyFor(settings, secrets);
-  if (!key) {
-    throw new ApiError('NOT_CONFIGURED', { detail: `no Linear key for feedback in the secret store (service ${serviceOf(settings)}, account ${settings.workspace})` });
-  }
-  if (!cache.lookup) {
-    const data = await call(http, key, LOOKUP, { team: settings.team, project: settings.project });
-    const team = data.teams.nodes[0];
-    const project = data.projects.nodes[0];
-    if (!team || !project) {
-      throw new ApiError('NOT_CONFIGURED', { detail: `Linear team ${settings.team} or project ${settings.project} not found` });
-    }
-    cache.lookup = { teamId: team.id, projectId: project.id, assigneeId: data.viewer?.id || '', labels: Object.fromEntries(team.labels.nodes.map((label) => [label.name.toLowerCase(), label.id])) };
-  }
-  const labelId = cache.lookup.labels[(KINDS[kind] || kind).toLowerCase()];
-  const assigneeId = settings.assign === false ? '' : cache.lookup.assigneeId;
-  const input = { teamId: cache.lookup.teamId, projectId: cache.lookup.projectId, title: cleanTitle, description: describe({ kind, body, context, from }), ...(labelId ? { labelIds: [labelId] } : {}), ...(assigneeId ? { assigneeId } : {}) };
-  const data = await call(http, key, CREATE, { input });
-  if (!data.issueCreate?.success) {
-    throw new ApiError('UPSTREAM_FAILED');
-  }
-  const issue = data.issueCreate.issue;
+  const text = String(body || '').trim().slice(0, 6000);
+  const issue = await call(http, relayUrl, { method: 'POST', body: { product: PRODUCT, kind, title: cleanTitle, body: text || cleanTitle, version: version || undefined, environment: environmentOf({ sources, install, client }) } });
   if (reports) {
-    reports.add({ id: issue.identifier, number: issue.number, url: issue.url, title: issue.title, kind, body: String(body || '').trim(), filed_at: nowIso() });
+    reports.add({ id: issue.identifier, url: issue.url, title: cleanTitle, kind, body: text, filed_at: nowIso() });
   }
-  return issue;
+  return { identifier: issue.identifier, url: issue.url, title: cleanTitle };
 };

package/lib/linear-api.mjs

@@ -1,4 +1,4 @@
-/** The one Linear GraphQL client, shared by the Linear connector and the feedback composer. */
+/** The one Linear GraphQL client, used by the Linear connector. */
 
 const API = 'https://api.linear.app/graphql';
 

package/lib/notify.mjs

@@ -26,18 +26,17 @@ 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 } }, () => {});
 };
 
-export const notify = (title, body, { platform = process.platform, run = launch } = {}) => {
+/** Sends one desktop notification; `enabled: false` stays silent. */
+export const notify = (title, body, { platform = process.platform, run = launch, enabled = true } = {}) => {
   const build = COMMANDS[platform];
-  if (build) {
+  if (build && enabled) {
     run(...build(clean(title, 120), clean(body, 240)));
   }
 };
+
+/** 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() });