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

package/lib/feedback.mjs

@@ -1,147 +1,115 @@
-/** 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;
+const STATE_NAMES = { open: 'Open', 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 serviceOf = (settings) => settings.token_service || DEFAULT_SERVICE;
-const keyFor = async (settings, secrets) => (settings && settings.workspace ? secrets.get(serviceOf(settings), settings.workspace) : '');
+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;
 
-/** 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. RMA-120, RMA-123. */
+export const openReports = (dataDir, { http, relayUrl }) => {
   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;
+  let cached = null;
+  const live = async () => {
+    if (cached && Date.now() - cached.at < 60000) {
+      return cached.value;
     }
-    const value = await read();
-    cache.set(name, { at: Date.now(), value });
+    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 = {};
+      }
+    }
+    cached = { 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 merged = (report, issue) => (issue ? { ...report, title: issue.title, state: STATE_NAMES[issue.outcome] || issue.outcome, outcome: issue.outcome, changed_at: issue.updatedAt } : report);
   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);
+    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]));
+    },
+    detail: async (id) => {
+      const report = items.find((item) => item.id === id);
       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 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 };
     },
   };
 };
 
-/** 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,11 +26,22 @@ const COMMANDS = {
   ],
 };
 
-const launch = (file, args, env) => execFile(file, args, { env: { ...process.env, ...env } }, () => {});
+/** 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';
 
-export const notify = (title, body, { platform = process.platform, run = launch } = {}) => {
+const launch = (file, args, env) => {
+  if (!muted()) {
+    execFile(file, args, { env: { ...process.env, ...env } }, () => {});
+  }
+};
+
+/** 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. */
+export const notifier = (isOn) => (title, body) => notify(title, body, { enabled: isOn() });

package/lib/registry.mjs

@@ -1,9 +1,9 @@
 /** 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, build, normalise = (raw) => raw }) => {
+export const createRegistry = ({ load, save, saveNotifications, build, normalise = (raw) => raw }) => {
   const listeners = new Set();
-  const registry = { workspaces: [], rawWorkspaces: [], problems: [], configFile: '', feedback: null, subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); } };
+  const registry = { workspaces: [], rawWorkspaces: [], problems: [], configFile: '', feedback: null, notifications: { desktop: true }, 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]));
@@ -29,6 +29,7 @@ export const createRegistry = ({ load, save, build, normalise = (raw) => raw })
     }).filter(Boolean);
     registry.rawWorkspaces = config.rawWorkspaces;
     registry.feedback = config.feedback;
+    registry.notifications = config.notifications;
     registry.problems = [...config.problems, ...dropped];
     registry.configFile = config.configFile;
     return created;
@@ -56,6 +57,10 @@ export const createRegistry = ({ load, save, build, normalise = (raw) => raw })
     await save(rawWorkspaces);
     return apply(load(), prebuilt);
   };
+  registry.saveNotifications = async (notifications) => {
+    await saveNotifications(notifications);
+    registry.reload();
+  };
   registry.reload();
   return registry;
 };

package/lib/rules.mjs

@@ -19,7 +19,7 @@ export const compileRules = (rules) => {
   };
 };
 
-const youOr = (name, myName) => (myName && name === myName ? 'you' : name);
+export 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: '',
@@ -176,9 +176,12 @@ export const turnRows = ({ tickets = [], prs = [], comments = [], asks = [], run
   return rows;
 };
 
+/** The feed id of a ticket event the monitor itself recorded. */
+export const eventId = (event) => `event:${event.key}:${event.at}:${event.kind}`;
+
 const feedItem = (fields) => ({ who: '', text: '', body: '', key: '', title: '', ...fields });
 
-export const feedRows = ({ activity = [], events = [], tickets = [], comments = [], asks = [] }, { me = {}, rules, historyDays = 14 }) => {
+export const feedRows = ({ activity = [], events = [], tickets = [], comments = [], asks = [], notes = [] }, { me = {}, rules, historyDays = 14 }) => {
   const cutoff = daysAgoIso(historyDays);
   const recentComments = comments.filter((comment) => comment.at >= cutoff);
   const rows = [
@@ -192,7 +195,8 @@ export const feedRows = ({ activity = [], events = [], tickets = [], comments =
         text: oneline(comment.body), body: comment.body, url: comment.url,
       });
     }),
-    ...events.map((event) => feedItem({ id: `event:${event.key}:${event.at}:${event.kind}`, 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.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);
   for (const ticket of tickets) {

package/lib/store.mjs

@@ -1,4 +1,4 @@
-/** One workspace's files on disk: state.json (last poll per source), marks.json (seen, handled, notified, health alerts already announced), todos.json and cache.json (connector caches that are data). */
+/** One workspace's files on disk: state.json (last poll per source), marks.json (seen, handled with its info, notified, health alerts already announced), todos.json and cache.json (connector caches that are data). */
 import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { join, resolve, sep } from 'node:path';
 import { DAY } from './text.mjs';
@@ -31,7 +31,7 @@ export const openStore = (dataDir, workspaceId) => {
   mkdirSync(dir, { recursive: true });
   const files = { state: join(dir, 'state.json'), marks: join(dir, 'marks.json'), todos: join(dir, 'todos.json'), cache: join(dir, 'cache.json') };
   const state = { version: 0, errors: {}, polled_at: '', fails: {}, sources: {}, events: [], ...readJson(files.state, {}) };
-  const marks = { seen: [], base: null, handled: {}, notified: [], notified_seeded: false, health_alerted: [], ...readJson(files.marks, {}) };
+  const marks = { seen: [], base: null, handled: {}, info: {}, notified: [], notified_seeded: false, health_alerted: [], ...readJson(files.marks, {}) };
   if (!marks.base) {
     marks.base = Date.now() - 3 * DAY;
   }

package/lib/text.mjs

@@ -16,6 +16,9 @@ export const oneline = (text, limit = 140) => {
   return flat.length <= limit ? flat : `${flat.slice(0, limit - 1)}…`;
 };
 
+/** True for a plain object: not null, not an array. */
+export const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
 export const escapeRegex = (text) => String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
 export const wordsRegex = (words, flags = 'i') => new RegExp(words.length ? words.map(escapeRegex).join('|') : '(?!)', flags);

package/lib/trace.mjs

@@ -0,0 +1,45 @@
+/** 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 { DAY, oneline } from './text.mjs';
+
+const lastName = (text) => String(text).split(' → ').pop().trim();
+
+/** Ticket rows that were on you before a poll and are on someone else after it. */
+export const passedRows = (before, after) => {
+  const later = new Map(after.map((row) => [row.row_id, row]));
+  return before
+    .filter((row) => row.group === 'you' && row.row_id === row.key && later.get(row.row_id)?.group === 'others')
+    .map((row) => ({ before: row, after: later.get(row.row_id) }));
+};
+
+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. */
+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;
+};
+
+/** `{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 = {}) => {
+  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');
+  const merge = mergedNow(pair) && feed.find((item) => item.kind === 'merged' && item.key === pair.after.key);
+  if (merge) {
+    return { outcome: 'Merged', event: merge.id, detail: { summary: 'Pull request merged' } };
+  }
+  if (reassigned) {
+    const names = reassigned.text.split(' → ');
+    const name = names.at(-1).trim();
+    const base = name ? `Passed to ${name}` : 'Passed on';
+    const comment = commentBefore(feed, pair.after.key, reassigned.at);
+    const head = status ? `${base} · ${lastName(status.text)}` : base;
+    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 } : {}) },
+    };
+  }
+  return status ? { outcome: `Moved to ${lastName(status.text)}`, event: eventId(status), detail: { status: status.text } } : null;
+};

package/lib/workspace.mjs

@@ -1,7 +1,8 @@
 /** One workspace: polls its connector entries, stores each result by source, merges them by kind, evaluates the rules once per version and notifies. */
 import { openStore } from './store.mjs';
 import { compileRules, turnRows, feedRows, myMoves, isHandled, withHandled, turnCounts, ticketEvents } from './rules.mjs';
-import { makeKeyFinder, nowIso, daysAgoIso, unionCapped, DAY } from './text.mjs';
+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';
@@ -44,6 +45,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   const listeners = new Set();
   let digest = '';
   let derived = null;
+  let marksVersion = 0;
   let freshAt = '';
   const startedAt = nowIso();
 
@@ -55,17 +57,34 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     return base ? `${base}${key}` : '';
   };
 
+  const noteEvents = () => Object.entries(store.marks.info)
+    .filter(([rowId, detail]) => detail.note && store.marks.handled[rowId])
+    .map(([rowId, detail]) => ({ id: `note:${rowId}:${store.marks.handled[rowId]}`, at: store.marks.handled[rowId], source: detail.source, key: detail.key, text: detail.note, url: detail.url }));
+
   const rows = () => {
     const day = nowIso().slice(0, 10);
-    if (!derived || derived.version !== store.state.version || derived.day !== day) {
+    if (!derived || derived.version !== store.state.version || derived.day !== day || derived.marksVersion !== marksVersion) {
       const sources = merged();
-      const state = { ...sources, events: store.state.events };
+      const state = { ...sources, events: store.state.events, notes: noteEvents() };
       const context = { me: me(), rules, historyDays, ticketUrl };
-      derived = { version: store.state.version, day, turn: turnRows(sources, context), feed: feedRows(state, context) };
+      derived = { version: store.state.version, marksVersion, day, turn: turnRows(sources, context), feed: feedRows(state, context) };
     }
     return derived;
   };
 
+  /** Saves the marks and, when what rows() derives from them (a note on a handled row) may have moved, drops the derived rows. */
+  const marksChanged = (derivedMoved = true) => {
+    if (derivedMoved) {
+      marksVersion += 1;
+    }
+    store.saveMarks();
+  };
+
+  const unmark = (rowId) => {
+    delete store.marks.handled[rowId];
+    delete store.marks.info[rowId];
+  };
+
   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 };
     for (const listener of listeners) {
@@ -143,6 +162,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     const state = store.state;
     const errors = {};
     const ticketsBefore = merged().tickets;
+    const turnBefore = rows().turn;
     definition.connectors.forEach((entry, index) => {
       const outcome = outcomes[index];
       Object.assign(errors, outcome.errors);
@@ -155,9 +175,8 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
         delete state.sources[id];
       }
     }
-    if (ticketsBefore.length) {
-      state.events = [...ticketEvents(ticketsBefore, merged().tickets), ...state.events].slice(0, 500);
-    }
+    const fresh = ticketsBefore.length ? ticketEvents(ticketsBefore, merged().tickets) : [];
+    state.events = [...fresh, ...state.events].slice(0, 500);
     state.errors = errors;
     state.polled_at = nowIso();
     if (outcomes.some((outcome) => outcome.data)) {
@@ -171,6 +190,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
       digest = next;
       state.version += 1;
       store.saveState();
+      recordTrace(turnBefore, fresh);
       if (outcomes.some((outcome) => outcome.data)) {
         notifyNewMoves();
         store.marks.notified_seeded = true;
@@ -187,6 +207,36 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     return { errors, rateLimited: outcomes.some((outcome) => outcome.rateLimited) };
   };
 
+  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. */
+  const recordTrace = (turnBefore, fresh) => {
+    const { turn, feed } = rows();
+    const { handled, info } = store.marks;
+    let changed = false;
+    let notesMoved = false;
+    for (const pair of passedRows(turnBefore, turn)) {
+      const trace = traceOf(pair, fresh, feed, me());
+      if (trace) {
+        const rowId = pair.after.row_id;
+        notesMoved ||= Boolean(info[rowId]?.note);
+        handled[rowId] = [handled[rowId] || '', nowIso(), pair.after.activity_at || ''].sort().pop();
+        info[rowId] = { ...info[rowId], ...rowRef(pair.after), auto: true, outcome: trace.outcome, event: trace.event, detail: trace.detail };
+        changed = true;
+      }
+    }
+    for (const [rowId, detail] of Object.entries(info)) {
+      if (detail.auto && turn.some((row) => row.row_id === rowId && row.group === 'you')) {
+        notesMoved ||= Boolean(detail.note);
+        unmark(rowId);
+        changed = true;
+      }
+    }
+    if (changed) {
+      marksChanged(notesMoved);
+    }
+  };
+
   const quickLinks = () => mergeLinks(definition.links || [], definition.connectors.flatMap((entry) => (CONNECTORS[entry.type]?.links ? CONNECTORS[entry.type].links(entry) : [])));
 
   const expireHandled = () => {
@@ -194,12 +244,12 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     let changed = false;
     for (const [rowId, at] of Object.entries(store.marks.handled)) {
       if (new Date(at).getTime() < limit) {
-        delete store.marks.handled[rowId];
+        unmark(rowId);
         changed = true;
       }
     }
     if (changed) {
-      store.saveMarks();
+      marksChanged();
     }
   };
 
@@ -244,6 +294,16 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     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() };
   };
 
+  const noteOn = (rowId, text) => {
+    const line = oneline(text || '', 200);
+    const row = rows().turn.find((candidate) => candidate.row_id === rowId);
+    if (!store.marks.handled[rowId] || (!line && !store.marks.info[rowId]?.note)) {
+      return;
+    }
+    const { note, ...rest } = { ...(row ? rowRef(row) : {}), ...store.marks.info[rowId] };
+    store.marks.info[rowId] = line ? { ...rest, note: line } : rest;
+  };
+
   const updateMarks = (body) => {
     const marks = store.marks;
     if (body.seen) {
@@ -258,12 +318,15 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
     }
     for (const [rowId, value] of Object.entries(body.handled || {})) {
       if (value === null) {
-        delete marks.handled[rowId];
+        unmark(rowId);
       } else {
         marks.handled[rowId] = value;
       }
     }
-    store.saveMarks();
+    for (const [rowId, text] of Object.entries(body.notes || {})) {
+      noteOn(rowId, text);
+    }
+    marksChanged(Object.keys(body.handled || {}).length + Object.keys(body.notes || {}).length > 0);
     emit();
     return marked();
   };
@@ -303,7 +366,7 @@ export const createWorkspace = (definition, { dataDir, historyDays, http, secret
   };
 
   return {
-    id: definition.id, name: definition.name, rulesTable: rules.table, store, poll, snapshot, summary, describe, checkHealth, handOff, handOffBody, handOffText, handOffSnapshot, updateMarks, addTodo, changeTodo, saveTodos,
+    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,
     subscribe: (listener) => { listeners.add(listener); return () => listeners.delete(listener); },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whose-turn",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.8",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -37,13 +37,15 @@
     "lint:style": "stylelint \"web/src/**/*.{vue,css}\"",
     "format": "prettier --write web/src",
     "check": "npm run typecheck && npm run lint && npm run lint:style && npm test && npm run test:web",
-    "test:web": "vitest run"
+    "test:web": "vitest run",
+    "mutation": "stryker run"
   },
   "bin": {
     "whose-turn": "server.mjs"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
+    "@stryker-mutator/core": "^10.1.1",
     "@testing-library/dom": "10.4.2",
     "@testing-library/vue": "8.1.0",
     "@types/node": "22.19.19",
@@ -66,5 +68,12 @@
     "vue": "^3.5.0",
     "vue-eslint-parser": "10.4.1",
     "vue-tsc": "3.3.13"
+  },
+  "overrides": {
+    "qs": "^6.16.1",
+    "fast-uri": "^3.1.9",
+    "zod": "^4.6.7",
+    "minimatch": "^11.0.4",
+    "glob": "^14.0.3"
   }
 }