create-pmos 0.48.0 → 0.50.0

package/workspace/public/pm/view-livenotes.js

@@ -0,0 +1,397 @@
+/* pm/view-livenotes.js — the Live notes view tab: confirm each talking point as it arrives (jev-live-notes, Run 6).
+ *
+ * The PM types or pastes what is being said, one point per line. Each point comes back at once as a card with a guess: the
+ * open initiative that shares the most words with it, and an open question when one shares at least two. The guess is a
+ * LOCAL WORD MATCH made in the workspace process (lib/live-notes.js, the `local` path): no model, no Jev, no request leaves
+ * the machine, and a guess is never shown above "possible". The PM confirms it, picks another relation or initiative, or
+ * rejects it, one card at a time. Waiting cards are on top; decided cards drop below. Closing the session files a section in
+ * the day's requirements note and deletes the raw transcript.
+ *
+ * Reads and writes, all on this repository's workspace:
+ *   GET  /api/live-notes?ws=…            the sessions        GET  /api/live-notes?ws=…&session=…   one session, ranked, + its shortlist
+ *   POST /api/live-notes/session         start or resume     POST /api/live-notes/add              typed points
+ *   POST /api/live-notes/decide          accept · change · reject                POST /api/live-notes/close   file the note
+ * Points an agent session adds through the command (Runs 1 to 5) appear here on the next read. In the fixture nothing is read.
+ *
+ * LISTENING. "Start listening" uses the browser's speech recognition with `processLocally = true`: the audio is recognised on this
+ * device (Chrome 139 and later, after a one-time language download) and never sent anywhere. A browser that cannot recognise on
+ * the device is told so; there is no fallback to cloud recognition. Interim words show live and are never added. A final phrase
+ * is added at a sentence end or after a pause, and the server cleans it (fillers, stumbles, a sentence end) before it becomes a
+ * point. "This meeting is private" stops listening and marks the session, so Run 7 never sends a point from it.
+ *
+ * JEV (Run 7, D85). "Check with Jev" is the per-repository switch, default off. When it, a saved key and consent for the repository
+ * all hold, the server hands each cleaned point to Jev with the shortlist, and the card says "from Jev". When a gate is shut the
+ * view says which, in words, and the local word match answers. A point Jev could not answer gets the local guess and says so.
+ *   POST /api/live-notes/switch          { ws, live }: the switch; the reply carries the gates again
+ */
+import { el } from './dom.js';
+
+const BTN = 'font:500 12.5px var(--sans);background:transparent;color:var(--foreground);border:1px solid var(--input);border-radius:8px;padding:0 12px;height:30px;min-height:30px;display:inline-grid;place-items:center;cursor:pointer;flex:none;white-space:nowrap';
+const BTNP = 'font:500 12.5px var(--sans);background:var(--foreground);color:var(--background);border:0;border-radius:8px;padding:0 12px;height:30px;min-height:30px;display:inline-grid;place-items:center;cursor:pointer;flex:none;white-space:nowrap';
+const CHIP = 'font:500 12px var(--sans);background:transparent;color:var(--foreground);border:1px solid var(--border);border-radius:999px;padding:0 10px;height:26px;cursor:pointer;white-space:nowrap';
+const CHIP_ON = 'font:500 12px var(--sans);background:var(--foreground);color:var(--background);border:1px solid var(--foreground);border-radius:999px;padding:0 10px;height:26px;cursor:pointer;white-space:nowrap';
+const CARD = 'border:1px solid var(--border);background:var(--background);border-radius:10px;padding:12px 14px;display:flex;flex-direction:column;gap:8px';
+const SELECT = 'font:13px var(--sans);background:var(--background);color:var(--foreground);border:1px solid var(--input);border-radius:8px;height:30px;padding:0 8px;max-width:100%';
+const NOTE = 'color:var(--muted-foreground);font-size:13px;line-height:1.5';
+const LBL = 'font:500 10px var(--mono);letter-spacing:.1em;text-transform:uppercase;color:var(--muted-foreground)';
+
+/** The relations the PM can pick, in words. `none` is the initiative picker's "none of these", not a chip. */
+export const RELATION_CHIPS = [
+  { key: 'validates', label: 'validates' }, { key: 'clarifies', label: 'clarifies' }, { key: 'extends', label: 'extends' },
+  { key: 'contradicts', label: 'contradicts' }, { key: 'answers', label: 'answers a question' },
+];
+const REFRESH_MS = 5000;
+
+/* ── module state: survives the redraw every setState causes ─────────────────────────────────── */
+const reads = new Map();      // key -> { state, data, error, at }
+const drafts = new Map();     // segment -> { initiative, relation, question } the PM's choice before Confirm
+const errors = new Map();     // segment -> the server's refusal, in words
+const sessionOf = new Map();  // ws -> the session shown
+let withheldNow = [];         // the last add's withheld points: { id, reason } — the text is never kept
+let banner = null;            // { tone, text }
+let anchorAsk = null;         // { ws, anchors: [{anchor, open}], error }
+let busy = false;
+let switching = false;
+let input = null;             // the textarea, kept across redraws so typing is not lost
+let dataMod = null; let dataTried = false;
+let listen = null;            // { ws, session, state: 'checking'|'on'|'needs-install'|'installing'|'unsupported'|'error', rec, interim, buffer, timer, lang, msg }
+const PAUSE_MS = 1500;        // a pause this long ends a point
+
+function read(ctx, key, url, ttl = REFRESH_MS) {
+  const hit = reads.get(key);
+  if (hit && (hit.state === 'loading' || Date.now() - hit.at < ttl)) return hit;
+  const next = { state: hit ? hit.state : 'loading', data: hit ? hit.data : null, error: hit ? hit.error : null, at: Date.now() };
+  reads.set(key, next);
+  fetch(url).then((r) => r.json()).then(
+    (d) => {
+      const same = hit && JSON.stringify(hit.data) === JSON.stringify(d);
+      reads.set(key, { state: d && d.ok === false ? 'error' : 'ok', data: d, error: d && d.error, at: Date.now() });
+      if (!same) ctx.setState({});   // redraw only when something changed, so a refresh does not disturb typing
+    },
+    (e) => { reads.set(key, { state: 'error', data: null, error: (e && e.message) || String(e), at: Date.now() }); ctx.setState({}); },
+  );
+  return next;
+}
+async function post(url, body) {
+  try { return await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }).then((r) => r.json()); }
+  catch (e) { return { ok: false, error: (e && e.message) || 'the workspace server did not answer' }; }
+}
+const forget = (ws, session) => { reads.delete('sessions:' + ws); if (session) reads.delete('session:' + ws + ':' + session); };
+
+async function setJev(ctx, ws, on) {
+  if (switching) return;
+  switching = true; ctx.setState({});
+  const r = await post('/api/live-notes/switch', { ws, live: on });
+  switching = false;
+  if (!r || !r.ok) banner = { tone: 'bad', text: (r && r.error) || 'the switch did not change' };
+  else banner = null;
+  forget(ws, sessionOf.get(ws));
+  ctx.setState({});
+}
+const FLAG_WORDS = {
+  'jev-not-reached': 'Jev was not reached, so this is the local word match.',
+  'jev-unreadable': 'Jev\'s answer could not be read, so this is the local word match.',
+};
+
+/** Every point of a ranked session, flat: waiting first (newest on top), then decided (newest on top). */
+export function feedOf(ranked) {
+  const all = [];
+  for (const sec of (ranked && ranked.sections) || []) for (const x of sec.items) all.push(x);
+  const newest = (a, b) => String(b.at || '').localeCompare(String(a.at || '')) || String(b.segment).localeCompare(String(a.segment));
+  return { waiting: all.filter((x) => !x.decision).sort(newest), decided: all.filter((x) => x.decision).sort(newest) };
+}
+/** The counter's numbers. */
+export function countsOf(ranked) {
+  const f = feedOf(ranked);
+  const by = (a) => f.decided.filter((x) => x.decision.action === a).length;
+  return { confirmed: by('accept'), changed: by('change'), rejected: by('reject'), waiting: f.waiting.length, withheld: (ranked && ranked.withheld) || 0 };
+}
+
+/* ── actions ──────────────────────────────────────────────────────────────────────────────────── */
+async function startSession(ctx, ws, anchor) {
+  busy = true; banner = null; ctx.setState({});
+  const r = await post('/api/live-notes/session', { ws, anchor: anchor || null });
+  busy = false;
+  if (r && r.ok) { sessionOf.set(ws, r.session); anchorAsk = null; withheldNow = []; forget(ws, r.session); }
+  else if (r && Array.isArray(r.anchors)) anchorAsk = { ws, anchors: r.anchors, error: r.error };
+  else banner = { tone: 'bad', text: (r && r.error) || 'the session did not start' };
+  ctx.setState({});
+}
+async function addPoints(ctx, ws, session) {
+  const text = input ? input.value : '';
+  if (!text.trim() || busy) return;
+  busy = true; banner = null; ctx.setState({});
+  const r = await post('/api/live-notes/add', { ws, session, text });
+  busy = false;
+  if (r && r.ok) {
+    if (input) input.value = '';
+    withheldNow = r.withheld || [];
+    reads.set('session:' + ws + ':' + session, { state: 'ok', data: { ok: true, session, ranked: r.ranked, shortlist: (reads.get('session:' + ws + ':' + session) || {}).data?.shortlist || [] }, at: 0 });
+    forget(ws, null);
+  } else banner = { tone: 'bad', text: (r && r.error) || 'nothing was added' };
+  ctx.setState({});
+}
+async function decide(ctx, ws, session, item, action) {
+  const d = drafts.get(item.segment) || {};
+  const initiative = d.initiative || item.initiative;
+  const relation = initiative === 'none' ? null : (d.relation !== undefined ? d.relation : item.relation);
+  const question = relation === 'answers' ? (d.question != null ? d.question : (item.answers_question && item.answers_question.initiative === initiative ? item.answers_question.n : null)) : null;
+  if (action !== 'reject' && initiative !== 'none' && !relation) { errors.set(item.segment, 'Pick how this point relates to ' + initiative + ' first.'); ctx.setState({}); return; }
+  if (action !== 'reject' && relation === 'answers' && question == null) { errors.set(item.segment, '"Answers" needs the open question it answers. Pick one.'); ctx.setState({}); return; }
+  const same = initiative === item.initiative && relation === item.relation && (relation !== 'answers' || (item.answers_question && item.answers_question.n === question));
+  const body = { ws, session, segment: item.segment, action: action === 'reject' ? 'reject' : same ? 'accept' : 'change' };
+  if (body.action === 'change') Object.assign(body, { initiative, relation: relation || null, question });
+  const r = await post('/api/live-notes/decide', body);
+  if (r && r.ok) { errors.delete(item.segment); drafts.delete(item.segment); forget(ws, session); }
+  else errors.set(item.segment, (r && r.error) || 'not recorded');
+  ctx.setState({});
+}
+/* ── listening: on-device speech recognition only ─────────────────────────────────────────────── */
+const SRClass = () => (typeof window !== 'undefined' ? window.SpeechRecognition || window.webkitSpeechRecognition : null);
+function stopListening() {
+  if (!listen) return;
+  const l = listen; listen = null;
+  clearTimeout(l.timer);
+  if (l.rec) { l.rec.onend = null; try { l.rec.stop(); } catch { /* already stopped */ } }
+}
+async function flush(ctx, l) {
+  clearTimeout(l.timer); l.timer = null;
+  const text = l.buffer.join(' ').trim(); l.buffer = [];
+  if (!text) return;
+  // one point per sentence; the server cleans each line before it becomes a point
+  const lines = text.split(/(?<=[.?!])\s+/).join('\n');
+  const r = await post('/api/live-notes/add', { ws: l.ws, session: l.session, text: lines, source: 'speech' });
+  if (r && r.ok) { withheldNow = (r.withheld || []).concat(withheldNow).slice(0, 5); reads.delete('session:' + l.ws + ':' + l.session); forget(l.ws, null); }
+  else if (r && r.error && !/type a talking point/.test(r.error)) banner = { tone: 'bad', text: 'A spoken point was not added: ' + r.error };
+  ctx.setState({});
+}
+async function startListening(ctx, ws, session, install = false) {
+  stopListening();
+  const C = SRClass();
+  const lang = (typeof navigator !== 'undefined' && navigator.language) || 'en-US';
+  listen = { ws, session, state: 'checking', rec: null, interim: '', buffer: [], timer: null, lang, msg: null };
+  ctx.setState({});
+  const l = listen;
+  if (!C || typeof C.available !== 'function') {
+    l.state = 'unsupported';
+    l.msg = 'This browser cannot recognise speech on this device, and live notes never send audio away. Chrome 139 or later can; until then, type the points.';
+    ctx.setState({}); return;
+  }
+  try {
+    if (install) { l.state = 'installing'; ctx.setState({}); await C.install({ langs: [lang], processLocally: true }); }
+    const a = await C.available({ langs: [lang], processLocally: true });
+    if (listen !== l) return;
+    if (a === 'downloadable' || a === 'downloading') { l.state = 'needs-install'; l.msg = 'Recognising ' + lang + ' on this device needs a one-time download by the browser.'; ctx.setState({}); return; }
+    if (a !== 'available') { l.state = 'unsupported'; l.msg = 'This browser cannot recognise ' + lang + ' on this device, and live notes never send audio away. Type the points instead.'; ctx.setState({}); return; }
+  } catch (e) { l.state = 'error'; l.msg = 'Speech recognition did not start: ' + ((e && e.message) || e); ctx.setState({}); return; }
+  const rec = new C();
+  rec.lang = lang; rec.continuous = true; rec.interimResults = true; rec.processLocally = true;
+  rec.onresult = (e) => {
+    if (listen !== l) return;      // a result that arrives after Stop or Private is dropped, never added
+    let interim = ''; let ended = false;
+    for (let i = e.resultIndex; i < e.results.length; i++) {
+      const res = e.results[i]; const t = String((res[0] && res[0].transcript) || '').trim();
+      if (!t) continue;
+      if (res.isFinal) { l.buffer.push(t); if (/[.?!]$/.test(t)) ended = true; } else interim += (interim ? ' ' : '') + t;
+    }
+    l.interim = interim;
+    clearTimeout(l.timer);
+    if (ended) flush(ctx, l); else if (l.buffer.length) l.timer = setTimeout(() => flush(ctx, l), PAUSE_MS);
+    const live = typeof document !== 'undefined' && document.querySelector('[data-ln-interim]');
+    if (live) live.textContent = interim; else ctx.setState({});
+  };
+  rec.onerror = (e) => {
+    if (e && (e.error === 'no-speech' || e.error === 'aborted')) return;
+    l.state = 'error'; l.msg = 'Listening stopped: ' + ((e && (e.message || e.error)) || 'the browser gave no reason') + '.'; ctx.setState({});
+  };
+  // the browser ends a recognition after a silence; while the PM has not pressed Stop, it starts again
+  rec.onend = () => { if (listen === l && l.state === 'on') { try { rec.start(); } catch { /* it is starting */ } } };
+  l.rec = rec;
+  try { rec.start(); l.state = 'on'; } catch (e) { l.state = 'error'; l.msg = 'Listening did not start: ' + ((e && e.message) || e); }
+  ctx.setState({});
+}
+async function markPrivate(ctx, ws, session) {
+  const l = listen;
+  stopListening();
+  if (l) l.buffer = [];
+  const r = await post('/api/live-notes/private', { ws, session });
+  banner = r && r.ok ? { tone: 'ok', text: 'Marked private. Listening stopped, and nothing from this session will be sent to any service.' } : { tone: 'bad', text: (r && r.error) || 'not marked' };
+  forget(ws, session);
+  ctx.setState({});
+}
+
+async function closeSession(ctx, ws, session) {
+  if (typeof window !== 'undefined' && window.confirm && !window.confirm('End this session? The points are filed in today\'s requirements note and the raw transcript is deleted.')) return;
+  if (listen && listen.session === session) { const l = listen; stopListening(); await flush(ctx, l); }
+  const r = await post('/api/live-notes/close', { ws, session });
+  banner = r && r.ok ? { tone: 'ok', text: r.already ? 'This session was already closed.' : 'Filed in ' + r.note + '. Raw transcript: ' + r.transcript + '.' } : { tone: 'bad', text: (r && r.error) || 'the session did not close' };
+  forget(ws, session);
+  ctx.setState({});
+}
+
+/* ── drawing ──────────────────────────────────────────────────────────────────────────────────── */
+const titleOf = (list, id) => { const i = (list || []).find((x) => x.id === id); return i ? i.title : id; };
+
+function card(ctx, ws, session, item, shortlist, closed) {
+  const decided = item.decision;
+  const parts = [el('div', { 'data-ln-quote': '', style: 'font-size:14px;line-height:1.5' }, '"' + item.quote + '"')];
+  const guess = item.initiative && item.initiative !== 'none'
+    ? 'Guess: about ' + titleOf(shortlist, item.initiative) + ' (' + (item.initiative_band || 'possible') + ')' + (item.relation ? ', ' + item.relation : '')
+    : 'Guess: matches no open initiative';
+  const by = item.path === 'local' ? 'local word match' : item.path === 'jev' || item.path === 'jev-agent' ? 'Jev' : 'agent session';
+  parts.push(el('div', { 'data-ln-guess': '', style: NOTE }, guess + ' · from ' + by));
+  if (item.answers_question) parts.push(el('div', { 'data-ln-question': '', style: NOTE }, 'May answer open question ' + item.answers_question.n + ': ' + item.answers_question.text));
+  for (const fl of item.flags || []) if (FLAG_WORDS[fl]) parts.push(el('div', { 'data-ln-flag': fl, style: NOTE }, FLAG_WORDS[fl]));
+  if (decided) {
+    const d = decided;
+    const said = d.action === 'reject' ? 'You rejected this.' : d.action === 'change' && d.now
+      ? 'You changed it: ' + (d.now.initiative === 'none' ? 'matches no initiative' : d.now.relation + ' ' + titleOf(shortlist, d.now.initiative)) + '.'
+      : 'You confirmed it.';
+    parts.push(el('div', { 'data-ln-decision': d.action, style: 'font:500 12.5px var(--sans);color:var(--muted-foreground)' }, said));
+    return el('div', { 'data-ln-card': item.segment, 'data-ln-state': 'decided', style: CARD + ';opacity:.72' }, parts);
+  }
+  if (closed) return el('div', { 'data-ln-card': item.segment, 'data-ln-state': 'waiting', style: CARD }, parts);
+
+  const d = drafts.get(item.segment) || {};
+  const ini = d.initiative || item.initiative || 'none';
+  const rel = ini === 'none' ? null : (d.relation !== undefined ? d.relation : item.relation);
+  const setDraft = (patch) => { drafts.set(item.segment, { ...d, ...patch }); errors.delete(item.segment); ctx.setState({}); };
+  const options = [el('option', { value: 'none', selected: ini === 'none' }, 'none of these initiatives')]
+    .concat((shortlist || []).map((i) => el('option', { value: i.id, selected: ini === i.id }, i.title + ' (' + i.id + ')')));
+  parts.push(el('div', { style: 'display:flex;gap:8px;align-items:center;flex-wrap:wrap' },
+    el('span', { style: LBL }, 'initiative'),
+    el('select', { 'data-ln-ini': '', style: SELECT, onChange: (e) => setDraft({ initiative: e.target.value, question: null }) }, options)));
+  if (ini !== 'none') {
+    parts.push(el('div', { 'data-ln-rels': '', style: 'display:flex;gap:6px;align-items:center;flex-wrap:wrap' },
+      el('span', { style: LBL }, 'relation'),
+      RELATION_CHIPS.map((c) => el('button', { 'data-ln-rel': c.key, 'aria-pressed': rel === c.key ? 'true' : 'false', style: rel === c.key ? CHIP_ON : CHIP,
+        onClick: () => setDraft({ relation: c.key }) }, c.label))));
+    if (rel === 'answers') {
+      const qs = ((shortlist || []).find((i) => i.id === ini) || {}).questions || [];
+      const cur = d.question != null ? d.question : (item.answers_question && item.answers_question.initiative === ini ? item.answers_question.n : null);
+      parts.push(qs.length
+        ? el('select', { 'data-ln-q': '', style: SELECT, onChange: (e) => setDraft({ question: e.target.value ? Number(e.target.value) : null }) },
+          [el('option', { value: '', selected: cur == null }, 'which open question?')].concat(qs.map((q, n) => el('option', { value: String(n + 1), selected: cur === n + 1 }, (n + 1) + '. ' + q.slice(0, 120)))))
+        : el('div', { style: NOTE }, titleOf(shortlist, ini) + ' has no open questions, so this point cannot answer one.'));
+    }
+  }
+  if (errors.get(item.segment)) parts.push(el('div', { 'data-ln-error': '', role: 'alert', style: 'color:var(--destructive);font-size:12.5px' }, errors.get(item.segment)));
+  parts.push(el('div', { style: 'display:flex;gap:8px' },
+    el('button', { 'data-ln-action': 'confirm', style: BTNP, onClick: () => decide(ctx, ws, session, item, 'confirm') }, 'Confirm'),
+    el('button', { 'data-ln-action': 'reject', style: BTN, hover: 'background:var(--accent)', onClick: () => decide(ctx, ws, session, item, 'reject') }, 'Reject')));
+  return el('div', { 'data-ln-card': item.segment, 'data-ln-state': 'waiting', style: CARD }, parts);
+}
+
+export function renderBoard(inner, ctx) {
+  const { FIXTURE } = ctx;
+  const repo = (ctx.tab && ctx.tab.repo) || ctx.repo || null;
+  let ws = null;
+  if (!FIXTURE) {
+    if (!dataTried) { dataTried = true; import('./data.js').then((m) => { dataMod = m; ctx.setState({}); }).catch(() => {}); }
+    if (dataMod && dataMod.wsOf) ws = dataMod.wsOf(repo);
+    if (!ws && ctx.state && ctx.state.product === repo) ws = ctx.state.wsId || null;
+  }
+  const typing = typeof document !== 'undefined' && input && document.activeElement === input;
+  const caret = typing ? [input.selectionStart, input.selectionEnd] : null;
+
+  const sess = !FIXTURE && ws ? read(ctx, 'sessions:' + ws, '/api/live-notes?ws=' + encodeURIComponent(ws), 15000) : null;
+  const jev = (sess && sess.data && sess.data.jev) || null;
+  const jevOn = !!(jev && jev.open);
+  inner.appendChild(el('div', { 'data-ln-part': 'header' },
+    el('div', { style: 'font:600 22px var(--sans);line-height:1.45' }, 'Live notes'),
+    jevOn
+      ? el('div', { 'data-ln-jev-on': '', style: NOTE },
+        'Listen or type what is being said. Each point is cleaned up and checked by Jev against your open initiatives; you confirm it, change it or reject it. '
+        + jev.note + ' Nothing changes an initiative until you confirm.')
+      : el('div', { 'data-ln-local': '', style: NOTE },
+        'Type what is being said, one point per line. Each point gets a guess at once; you confirm it, change it or reject it. '
+        + 'Guesses here are a local word match. Nothing leaves this machine, and nothing changes an initiative.')));
+  if (FIXTURE || !ws) { inner.appendChild(el('div', { style: NOTE + ';margin-top:12px' }, FIXTURE ? 'The fixture reads no sessions.' : 'Select a repository to take notes against.')); return; }
+
+  const sessions = (sess.data && sess.data.sessions) || [];
+  let current = sessionOf.get(ws);
+  if (!current && sessions.length) { const open = sessions.filter((s) => !s.closed); current = (open[open.length - 1] || sessions[sessions.length - 1]).session; sessionOf.set(ws, current); }
+
+  const bar = [el('span', { style: LBL }, 'session')];
+  if (sessions.length) {
+    bar.push(el('select', { 'data-ln-session': '', style: SELECT, onChange: (e) => { stopListening(); sessionOf.set(ws, e.target.value); withheldNow = []; banner = null; ctx.setState({}); } },
+      sessions.slice().reverse().map((s) => el('option', { value: s.session, selected: s.session === current }, s.session + (s.closed ? ' · closed' : '') + ' · ' + s.points + ' points'))));
+  } else bar.push(el('span', { style: NOTE }, sess.state === 'loading' ? 'reading …' : 'no sessions yet'));
+  bar.push(el('button', { 'data-ln-new': '', style: BTN, hover: 'background:var(--accent)', disabled: busy, onClick: () => { stopListening(); startSession(ctx, ws, null); } }, 'New session'));
+  inner.appendChild(el('div', { 'data-ln-part': 'sessions', style: 'display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-top:12px' }, bar));
+  if (jev) {
+    const sw = !!jev.switch;
+    const why = jev.open ? 'Jev is checking new points.'
+      : sw ? 'Jev is not used yet. ' + (jev.sentence || '')
+      : 'Jev is off. Points get the local word match only.';
+    inner.appendChild(el('div', { 'data-ln-part': 'jev', style: 'display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-top:10px' },
+      el('span', { style: LBL }, 'jev'),
+      el('button', { 'data-ln-jev': sw ? 'on' : 'off', 'aria-pressed': sw ? 'true' : 'false', disabled: switching, style: sw ? CHIP_ON : CHIP,
+        onClick: () => setJev(ctx, ws, !sw) }, sw ? 'Check with Jev: on' : 'Check with Jev: off'),
+      el('span', { 'data-ln-jev-state': jev.open ? 'open' : 'shut', style: NOTE }, why.trim())));
+  }
+
+  if (anchorAsk && anchorAsk.ws === ws) {
+    let pick = anchorAsk.anchors[0] ? anchorAsk.anchors[0].anchor : '';
+    inner.appendChild(el('div', { 'data-ln-part': 'anchor', style: CARD + ';margin-top:10px' },
+      el('div', { style: NOTE }, anchorAsk.error),
+      el('div', { style: 'display:flex;gap:8px;align-items:center;flex-wrap:wrap' },
+        el('select', { 'data-ln-anchor': '', style: SELECT, onChange: (e) => { pick = e.target.value; } },
+          anchorAsk.anchors.map((a) => el('option', { value: a.anchor }, a.anchor + ' · ' + a.open + ' open'))),
+        el('button', { 'data-ln-start': '', style: BTNP, onClick: () => startSession(ctx, ws, pick) }, 'Start with this anchor'))));
+  }
+  if (banner) inner.appendChild(el('div', { 'data-ln-banner': banner.tone, role: banner.tone === 'bad' ? 'alert' : 'status', style: 'margin-top:10px;font-size:13px;color:' + (banner.tone === 'bad' ? 'var(--destructive)' : 'var(--foreground)') }, banner.text));
+  if (!current) return;
+
+  const one = read(ctx, 'session:' + ws + ':' + current, '/api/live-notes?ws=' + encodeURIComponent(ws) + '&session=' + encodeURIComponent(current));
+  if (!one.data || !one.data.ranked) { inner.appendChild(el('div', { style: NOTE + ';margin-top:12px' }, one.state === 'error' ? 'Could not read this session: ' + one.error : 'reading the session …')); return; }
+  const ranked = one.data.ranked; const shortlist = one.data.shortlist || [];
+  const closed = !!ranked.closed;
+  const c = countsOf(ranked);
+  inner.appendChild(el('div', { 'data-ln-counter': '', style: 'display:flex;gap:14px;flex-wrap:wrap;margin-top:12px;font:500 12.5px var(--sans)' },
+    [['confirmed', c.confirmed], ['changed', c.changed], ['rejected', c.rejected], ['waiting', c.waiting], ['withheld', c.withheld]]
+      .map(([k, n]) => el('span', { 'data-ln-count': k }, n + ' ' + k))));
+  if (ranked.paused) inner.appendChild(el('div', { 'data-ln-paused': '', role: 'status', style: NOTE }, ranked.paused.reason));
+  if (ranked.private && jevOn) inner.appendChild(el('div', { 'data-ln-private-jev': '', style: NOTE }, 'Nothing from this meeting goes to Jev, because it is marked private.'));
+
+  if (!closed) {
+    // listening: on-device recognition, a visible "notes are being taken", Stop and Private
+    const mine = listen && listen.ws === ws && listen.session === current ? listen : null;
+    const lp = [];
+    if (ranked.private) lp.push(el('span', { 'data-ln-private': '', style: NOTE }, 'This meeting is marked private: listening is off for it.'));
+    else if (mine && mine.state === 'on') {
+      lp.push(el('span', { 'data-ln-listening': 'on', role: 'status', style: 'font:600 12.5px var(--sans);color:var(--destructive)' }, '● Listening: notes are being taken'));
+      lp.push(el('button', { 'data-ln-stop': '', style: BTN, hover: 'background:var(--accent)', onClick: () => { const l = listen; stopListening(); if (l) flush(ctx, l); ctx.setState({}); } }, 'Stop'));
+      lp.push(el('button', { 'data-ln-mark-private': '', style: BTN, hover: 'background:var(--accent)', onClick: () => markPrivate(ctx, ws, current) }, 'This meeting is private'));
+    } else {
+      lp.push(el('button', { 'data-ln-listen': '', style: BTNP, disabled: !!(mine && (mine.state === 'checking' || mine.state === 'installing')), onClick: () => startListening(ctx, ws, current) },
+        mine && mine.state === 'checking' ? 'Starting …' : mine && mine.state === 'installing' ? 'Downloading …' : 'Start listening'));
+      if (mine && mine.state === 'needs-install') lp.push(el('button', { 'data-ln-install': '', style: BTN, onClick: () => startListening(ctx, ws, current, true) }, 'Download for ' + mine.lang));
+      lp.push(el('span', { style: NOTE }, 'Speech is recognised on this device; no audio leaves it.'));
+    }
+    inner.appendChild(el('div', { 'data-ln-part': 'listen', style: 'display:flex;gap:8px;align-items:center;flex-wrap:wrap;margin-top:12px' }, lp));
+    if (mine && mine.msg && mine.state !== 'on') inner.appendChild(el('div', { 'data-ln-listen-msg': mine.state, style: NOTE }, mine.msg));
+    if (mine && mine.state === 'on') inner.appendChild(el('div', { 'data-ln-interim': '', style: 'min-height:20px;font-size:13px;font-style:italic;color:var(--muted-foreground)' }, mine.interim || ''));
+    if (!input) {
+      input = el('textarea', { 'data-ln-input': '', rows: '3', placeholder: 'One talking point per line. Enter adds; Shift+Enter starts a new line.',
+        style: 'font:14px var(--sans);width:100%;box-sizing:border-box;background:var(--background);color:var(--foreground);border:1px solid var(--input);border-radius:8px;padding:8px 10px;resize:vertical' });
+    }
+    input.onkeydown = (e) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); addPoints(ctx, ws, current); } };
+    inner.appendChild(el('div', { 'data-ln-part': 'input', style: 'display:flex;flex-direction:column;gap:8px;margin-top:12px' }, input,
+      el('div', { style: 'display:flex;gap:8px;align-items:center' },
+        el('button', { 'data-ln-add': '', style: BTNP, disabled: busy, onClick: () => addPoints(ctx, ws, current) }, busy ? 'Adding …' : 'Add'),
+        el('span', { style: 'flex:1' }),
+        el('button', { 'data-ln-close': '', style: BTN, hover: 'background:var(--accent)', onClick: () => closeSession(ctx, ws, current) }, 'End and file the note'))));
+    if (caret) requestAnimationFrame(() => { try { input.focus(); input.setSelectionRange(caret[0], caret[1]); } catch { /* the textarea is gone */ } });
+  } else inner.appendChild(el('div', { 'data-ln-closed': '', style: NOTE + ';margin-top:12px' }, 'This session is closed. Its points are filed in the requirements note; start a new session to take more notes.'));
+
+  for (const w of withheldNow) inner.appendChild(el('div', { 'data-ln-withheld': w.id, style: CARD + ';margin-top:8px;color:var(--muted-foreground)' }, 'A point was withheld and not kept: it ' + w.reason + '.'));
+
+  const f = feedOf(ranked);
+  const list = el('div', { 'data-ln-part': 'feed', style: 'display:flex;flex-direction:column;gap:8px;margin-top:12px' });
+  if (!f.waiting.length && !f.decided.length) list.appendChild(el('div', { style: NOTE }, 'No points yet.'));
+  for (const x of f.waiting) list.appendChild(card(ctx, ws, current, x, shortlist, closed));
+  if (f.decided.length) list.appendChild(el('div', { style: LBL + ';margin-top:8px' }, 'decided'));
+  for (const x of f.decided) list.appendChild(card(ctx, ws, current, x, shortlist, closed));
+  inner.appendChild(list);
+}

package/workspace/run-tests.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+'use strict';
+/* run-tests.js — run the workspace suites side by side.
+ *
+ *   node run-tests.js <group> [--jobs=N] [--shard=I/N] [--list] [--verbose]
+ *   node run-tests.js --check
+ *
+ * Groups come from test-files.json: unit (test.js + modules), modules, panels, ui, browser
+ * (panels + ui), all. The npm scripts call this file, so `npm test` and CI run the same lists.
+ *
+ * Running in parallel is safe because every suite claims its own ephemeral port, scratch state
+ * directory and private tmux socket (test-run.js, or the same three lines written out in the
+ * suite). It was checked rather than assumed: on 2026-10-05 all 48 browser suites ran four at a
+ * time with no failure that the serial run did not also show.
+ *
+ * Nothing is skipped. --shard splits a group across CI jobs; the shards partition the list (every
+ * file in exactly one shard), and --check fails when a suite on disk is in no list, so a new suite
+ * that nobody wired in is a red build rather than a suite that runs nowhere.
+ *
+ * Output: a suite's own output is buffered and printed whole when it finishes, so lines from two
+ * suites never interleave. A passing suite prints its last lines; --verbose prints all of it.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DIR = __dirname;
+const FILES = JSON.parse(fs.readFileSync(path.join(DIR, 'test-files.json'), 'utf8'));
+const GROUPS = {
+  unit: [...FILES.unit, ...FILES.modules],
+  modules: FILES.modules,
+  panels: FILES.panels,
+  ui: FILES.ui,
+  browser: [...FILES.panels, ...FILES.ui],
+  all: [...FILES.unit, ...FILES.modules, ...FILES.panels, ...FILES.ui],
+};
+// Suites that run elsewhere on purpose, so --check does not count them as unwired.
+const ELSEWHERE = {
+  'offline-tarball.test.js': 'npm run test:offline (needs a packed tarball)',
+};
+const PER_FILE_TIMEOUT_MS = 10 * 60 * 1000;
+
+const args = process.argv.slice(2);
+const flag = (name) => { const a = args.find((x) => x === `--${name}` || x.startsWith(`--${name}=`)); return a === undefined ? undefined : (a.includes('=') ? a.slice(a.indexOf('=') + 1) : true); };
+const group = args.find((a) => !a.startsWith('--'));
+
+const secs = (f) => Number((FILES.seconds || {})[f]) || 10;
+// Slowest first, so a long suite never starts last and holds the run open on its own.
+const bySlowest = (list) => list.map((f, k) => ({ f, k })).sort((a, b) => secs(b.f) - secs(a.f) || a.k - b.k).map((x) => x.f);
+
+// Deal the suites, slowest first, each to the shard with the least time so far (ties to the lower
+// shard). Deterministic, so every CI job computes the same split, and a partition by construction:
+// each suite goes to exactly one shard. --check proves the partition for every shard count it tries.
+function shardOf(list, spec) {
+  const m = /^(\d+)\/(\d+)$/.exec(String(spec));
+  if (!m) throw new Error(`--shard must look like 1/4, got "${spec}"`);
+  const i = Number(m[1]); const n = Number(m[2]);
+  if (n < 1 || i < 1 || i > n) throw new Error(`--shard ${spec}: the index must be between 1 and ${n}`);
+  const load = new Array(n).fill(0); const out = Array.from({ length: n }, () => []);
+  for (const f of bySlowest(list)) {
+    let best = 0; for (let k = 1; k < n; k++) if (load[k] < load[best]) best = k;
+    out[best].push(f); load[best] += secs(f);
+  }
+  return out[i - 1];
+}
+
+function check() {
+  const listed = new Set(GROUPS.all);
+  const problems = [];
+  const dupes = GROUPS.all.filter((f, k) => GROUPS.all.indexOf(f) !== k);
+  for (const f of new Set(dupes)) problems.push(`${f} is listed more than once in test-files.json`);
+  for (const f of listed) if (!fs.existsSync(path.join(DIR, f))) problems.push(`${f} is listed in test-files.json but does not exist`);
+  for (const f of FILES.exclusive || []) if (!listed.has(f)) problems.push(`${f} is marked exclusive but is in no test list`);
+  const onDisk = fs.readdirSync(DIR).filter((f) => f === 'test.js' || /(\.test\.(js|mjs)|-test\.js)$/.test(f));
+  for (const f of onDisk) if (!listed.has(f) && !ELSEWHERE[f]) problems.push(`${f} is a suite on disk that no test list runs. Add it to test-files.json.`);
+  for (const n of [2, 3, 4, 6, 8]) for (const g of ['unit', 'browser']) {
+    const parts = Array.from({ length: n }, (_, k) => shardOf(GROUPS[g], `${k + 1}/${n}`)).flat();
+    if (parts.length !== GROUPS[g].length || new Set(parts).size !== GROUPS[g].length) problems.push(`--shard does not partition "${g}" into ${n}`);
+  }
+  if (problems.length) { for (const p of problems) console.error(`✗ ${p}`); process.exitCode = 1; return; }
+  console.log(`✓ ${listed.size} suites listed, each once, each on disk; ${onDisk.length - Object.keys(ELSEWHERE).length} suites on disk, all listed; shards partition every group.`);
+}
+
+function runOne(file, verbose) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    const chunks = [];
+    const child = spawn(process.execPath, [file], { cwd: DIR, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+    child.stdout.on('data', (d) => chunks.push(d));
+    child.stderr.on('data', (d) => chunks.push(d));
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill('SIGKILL'); }, PER_FILE_TIMEOUT_MS);
+    child.on('close', (code, signal) => {
+      clearTimeout(timer);
+      const secs = ((Date.now() - t0) / 1000).toFixed(1);
+      const out = Buffer.concat(chunks).toString('utf8').replace(/\s+$/, '');
+      const ok = code === 0 && !timedOut;
+      const why = timedOut ? `timed out after ${PER_FILE_TIMEOUT_MS / 60000} min` : (signal ? `killed by ${signal}` : `exit ${code}`);
+      const lines = out.split('\n');
+      const body = ok && !verbose ? lines.slice(-3).join('\n') : out;
+      process.stdout.write(`\n── ${ok ? 'PASS' : 'FAIL'} ${file} (${secs}s${ok ? '' : ', ' + why}) ──\n${body}\n`);
+      resolve({ file, ok, secs: Number(secs), why });
+    });
+  });
+}
+
+async function main() {
+  if (flag('check')) return check();
+  if (!group || !GROUPS[group]) {
+    console.error(`usage: node run-tests.js <${Object.keys(GROUPS).join('|')}> [--jobs=N] [--shard=I/N] [--list] [--verbose]\n       node run-tests.js --check`);
+    process.exitCode = 2; return;
+  }
+  let list = GROUPS[group];
+  const shard = flag('shard');
+  list = shard ? shardOf(list, shard) : bySlowest(list);
+  if (flag('list')) { console.log(list.join('\n')); return; }
+  const cpus = typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length;
+  // A browser suite runs a server, a tmux daemon and a Chromium of its own, and several of them assert
+  // on timing. At one per CPU they starved each other: 2 of 48 failed per run on a 4-CPU machine, a
+  // different 2 each time, all green alone. Half the CPUs for any group with browser suites in it
+  // kept every run green. --jobs or PMOS_TEST_JOBS still overrides.
+  const hasBrowser = list.some((f) => FILES.panels.includes(f) || FILES.ui.includes(f));
+  const auto = hasBrowser ? Math.max(1, Math.floor(cpus / 2)) : cpus;
+  const jobs = Math.max(1, Number(flag('jobs')) || Number(process.env.PMOS_TEST_JOBS) || auto);
+  const verbose = !!flag('verbose');
+  console.log(`run-tests: ${group}${shard ? ` shard ${shard}` : ''} — ${list.length} suites, ${jobs} at a time`);
+
+  const t0 = Date.now();
+  const results = [];
+  // An exclusive suite writes the checkout's own state, so it runs alone: first the shared suites side
+  // by side, then each exclusive one with nothing beside it.
+  const exclusive = new Set(FILES.exclusive || []);
+  const shared = list.filter((f) => !exclusive.has(f));
+  let next = 0;
+  const worker = async () => { while (next < shared.length) { const f = shared[next++]; results.push(await runOne(f, verbose)); } };
+  await Promise.all(Array.from({ length: Math.min(jobs, shared.length) }, worker));
+  for (const f of list.filter((x) => exclusive.has(x))) results.push(await runOne(f, verbose));
+
+  const failed = results.filter((r) => !r.ok);
+  const slowest = [...results].sort((a, b) => b.secs - a.secs).slice(0, 5).map((r) => `${r.file} ${r.secs}s`).join(', ');
+  console.log(`\nrun-tests: ${results.length - failed.length}/${results.length} suites passed in ${((Date.now() - t0) / 1000).toFixed(1)}s wall. Slowest: ${slowest}.`);
+  // exitCode, never process.exit(): stdout to a pipe is asynchronous, and exiting here cut the CI log
+  // off mid-suite, before the summary that names what failed.
+  if (failed.length) { console.log(`FAILED: ${failed.map((r) => `${r.file} (${r.why})`).join(', ')}`); process.exitCode = 1; }
+}
+
+main().catch((e) => { console.error(e); process.exitCode = 1; });