create-pmos 0.48.0 → 0.49.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/server.js

@@ -76,6 +76,7 @@ const jevClaims = require('./lib/jev-claims.js');   // D80 — the bridge betwee
 const jevCategorize = require('./lib/jev-categorize.js');   // D82 — the bridge between the document categorizer and the one TypeSafe module
 const validateLib = require('./lib/validate.js');
 const liveNotes = require('./lib/live-notes.js');   // jev-live-notes — reads and appends a repository's live-notes ledger; no network
+const jevLive = require('./lib/jev-live.js');      // jev-live-notes Run 7 (D85) — the live view's one bridge to Jev, behind three gates
 const claimsLib = require('./lib/claims.js');
 const docCategory = require('./lib/doc-category.js');   // jev-doc-categorizer Run 1 — the PM-facing kind of a document, derived, local, no model
 const docCatCorrections = require('./lib/doc-category-corrections.js');   // jev-doc-categorizer Run 3 — the PM's own category, per user, outside the repository
@@ -291,6 +292,10 @@ function sessionEnv() {
   // print its environment, so the key is never handed to one, whether it came from settings or the shell.
   delete env[tsSettings.ENV_NAME];
   if (SET_GIT_OPTIONAL_LOCKS) delete env.GIT_OPTIONAL_LOCKS;
+  // prompt-model-routing Run 3 — where the cockpit mod asks for a prompt's route: this server, on loopback.
+  // An address only; the Jev key stays here (D79).
+  const routeUrl = jevRoute.routeUrl(PORT);
+  if (routeUrl) env.PMOS_ROUTE_URL = routeUrl; else delete env.PMOS_ROUTE_URL;
   return env;
 }
 
@@ -470,6 +475,12 @@ function homeWorkspace() {
   return HOME_ENABLED ? workspaces.get(wsId(SELF_ROOT)) : [...workspaces.values()][0];
 }
 function getWs(id) { return (id && workspaces.get(id)) || homeWorkspace(); }
+/** The registered workspace whose root is this path exactly, or null. Never the home workspace by default. */
+function wsByRoot(root) {
+  const want = path.resolve(String(root));
+  for (const w of workspaces.values()) if (w && path.resolve(w.root) === want) return w;
+  return null;
+}
 // R2/R3 — what the sidebar tree needs and cannot derive for itself: which REPOSITORY a registered
 // working tree belongs to, and which branch it is on. `git worktree list` names the main worktree
 // first from any of a repo's trees (git-info.worktreesAt), so index 0 is the group key: it is what
@@ -1608,8 +1619,8 @@ function annotateJev(root, node, cache, seen = new Set()) {
   if (node.category === docCategory.UNDETERMINED && typeof node.path === 'string' && /\.md$/i.test(node.path)) {
     const c = categoryInput(path.join(root, node.path));
     const l = c ? jevCategorize.lookup(cache, { fm: c.fm, text: c.text }) : null;
-    if (l && l.decided) { node.category = l.category; node.category_basis = 'jev'; node.category_why = l.sentence; if (l.ticket_kind) node.ticket_kind = l.ticket_kind; }
-    else if (l) node.category_why = l.sentence;
+    if (l && l.decided) { node.category = l.category; node.category_basis = 'jev'; node.category_why = l.sentence; if (l.ticket_kind) node.category_kind = l.ticket_kind; }
+    else if (l) { node.category_why = l.sentence; node.category_jev = 'unsure'; }
   }
   for (const k of Object.keys(node)) if (node[k] && typeof node[k] === 'object') annotateJev(root, node[k], cache, seen);
   return node;
@@ -4703,6 +4714,18 @@ function jevGateInfo(w) {
   const { cacheDir } = claimsPaths(w);
   return { switch: f.jev, status_read: f.status_read, open: g.open, missing: g.missing, sentence: g.open ? null : jevClaims.gateSentence(g.missing), ...jevClaims.status(cacheDir) };
 }
+// D85 — the live-notes add route's sender: lib/typesafe.js behind the key, consent and the switch, or none. The key goes to the engine
+// only when the sender does, and never into a response.
+function liveSender(w) {
+  const key = tsSettings.getKey(STATE);
+  const flags = { consent: tsSettings.getRepo(STATE, w.root).consent, live: liveNotes.getSwitch(STATE, w.root).live };
+  const snd = jevLive.senderFor(key, flags, jevModelOpts(w.root));
+  return { key: snd.ask ? key : null, flags, ask: snd.ask, askOpts: snd.askOpts };
+}
+// D85 — what the live-notes view needs to explain its Jev switch. Booleans and sentences only; the key never leaves the store.
+function liveJevInfo(w) {
+  return jevLive.infoFor(tsSettings.status(STATE).present, { consent: tsSettings.getRepo(STATE, w.root).consent, live: liveNotes.getSwitch(STATE, w.root).live });
+}
 // D82 — what the page needs to explain the categorize switch: which gates hold, and what the last pass did.
 const doccatRunning = new Set();
 const doccatAutoAt = new Map();    // root → time of the last automatic pass; at most one a minute
@@ -5555,11 +5578,13 @@ async function handleRequest(req, res) {
   }
   if (p === '/api/model/route' && req.method === 'POST') {
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
-    const w = getWs(body.ws); if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    // A terminal's cockpit mod names its repository by root; the page names a workspace by id.
+    const w = typeof body.root === 'string' ? wsByRoot(body.root) : getWs(body.ws);
+    if (!w) return json(res, { ok: false, error: 'no workspace for that repository' }, 400);
     if (typeof body.prompt !== 'string' || !body.prompt.trim() || body.prompt.length > 60000) return json(res, { ok: false, error: 'prompt must be text of up to 60000 characters' }, 400);
     const f = tsSettings.getRepo(STATE, w.root);
     const out = await jevRoute.routePrompt({ root: w.root, prompt: body.prompt, ctx: { skill: typeof body.skill === 'string' ? body.skill : undefined, source: body.source, running: true },
-      key: tsSettings.getKey(STATE), flags: { consent: f.consent, route: f.route, exclude: f.exclude } });
+      key: tsSettings.getKey(STATE), flags: { consent: f.consent, route: f.route, exclude: f.exclude }, askOpts: body.interactive === true ? jevRoute.INTERACTIVE : {} });
     if (!out.ok) return json(res, { ok: false, error: out.error }, 400);
     if (out.shadow) return json(res, { ok: true, shadow: true, id: out.id });             // shadow: logged, nothing shown, nothing applied
     return json(res, { ok: true, ws: w.id, id: out.id, tier: out.tier, model: out.model, effort: out.effort, stage: out.stage, confidence: out.confidence, why: out.why,
@@ -6566,12 +6591,14 @@ async function handleRequest(req, res) {
     return json(res, { ok: true, ws: w.id, name: w.name, ...tsSettings.getRepo(STATE, w.root), key: tsSettings.status(STATE) });
   }
   /* ── live notes (jev-live-notes, Run 2): the ranked proposals of a conversation, and the PM's accept, change or reject.
-   *    Reads the repository's ledger; the one write is a decision row. No request leaves this process, and no page is built yet. ── */
+   *    Reads the repository's ledger; the writes are ledger rows and, on close, the day's note. No request leaves this process.
+   *    The page is the cockpit's live-notes view (public/pm/view-livenotes.js, Run 6). ── */
   if (p === '/api/live-notes' && req.method === 'GET') {
     const wsq = url.searchParams.get('ws');
     const w = wsq ? workspaces.get(wsq) : homeWorkspace();     // a named workspace the server does not know is refused, never replaced by the home one
     if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
-    const r = liveNotes.apiList({ root: w.root, session: url.searchParams.get('session') || null });
+    const r = liveNotes.apiList({ root: w.root, session: url.searchParams.get('session') || null, exclude: tsSettings.getRepo(STATE, w.root).exclude });
+    if (r.ok) r.jev = liveJevInfo(w);
     return json(res, r, r.ok ? 200 : (r.status || 400));
   }
   if (p === '/api/live-notes/decide' && req.method === 'POST') {
@@ -6580,7 +6607,39 @@ async function handleRequest(req, res) {
     catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
     const w = body.ws ? workspaces.get(String(body.ws)) : homeWorkspace();
     if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
-    const r = liveNotes.apiDecide({ root: w.root, runtimeDir: STATE, session: body.session, segment: body.segment, action: body.action, initiative: body.initiative || null, relation: body.relation || null, exclude: tsSettings.getRepo(STATE, w.root).exclude });
+    const r = liveNotes.apiDecide({ root: w.root, runtimeDir: STATE, session: body.session, segment: body.segment, action: body.action, initiative: body.initiative || null, relation: body.relation || null, question: body.question == null ? null : body.question, exclude: tsSettings.getRepo(STATE, w.root).exclude });
+    return json(res, r, r.ok ? 200 : (r.status || 400));
+  }
+  /* Run 7 (D85): the per-repository switch "live notes may use Jev". Default off; it is one of three gates, with the key and consent. */
+  if (p === '/api/live-notes/switch' && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = body.ws ? workspaces.get(String(body.ws)) : homeWorkspace();
+    if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
+    if (typeof body.live !== 'boolean') return json(res, { ok: false, error: 'say live: true or live: false' }, 400);
+    liveNotes.setSwitch(STATE, w.root, { live: body.live });
+    return json(res, { ok: true, ws: w.id, jev: liveJevInfo(w) });
+  }
+  /* Run 6: the live-notes view's writes — start or resume a session, add points, close. A proposal is a local word match made in
+   * this process, unless all three D85 gates hold: then `add` hands each cleaned point to Jev through lib/jev-live.js. */
+  if ((p === '/api/live-notes/session' || p === '/api/live-notes/add' || p === '/api/live-notes/close' || p === '/api/live-notes/private') && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const w = body.ws ? workspaces.get(String(body.ws)) : homeWorkspace();
+    if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
+    const exclude = tsSettings.getRepo(STATE, w.root).exclude;
+    let r;
+    if (p === '/api/live-notes/session') r = liveNotes.apiOpen({ root: w.root, runtimeDir: STATE, session: body.session || null, anchor: body.anchor || null, exclude });
+    else if (p === '/api/live-notes/add') {
+      const snd = liveSender(w);
+      r = await liveNotes.apiAdd({ root: w.root, runtimeDir: STATE, session: body.session, text: body.text, source: body.source === 'speech' ? 'speech' : 'typed', exclude,
+        key: snd.key, flags: snd.flags, ask: snd.ask, askOpts: snd.askOpts });
+    }
+    else if (p === '/api/live-notes/private') r = liveNotes.apiMarkPrivate({ root: w.root, session: body.session });
+    else r = liveNotes.apiClose({ root: w.root, runtimeDir: STATE, session: body.session, retentionDays: liveNotes.getSwitch(STATE, w.root).retention_days, exclude });
+    if (r.ok && p !== '/api/live-notes/close') { r.jev = liveJevInfo(w); if (r.note) r.note = r.jev.note; }
     return json(res, r, r.ok ? 200 : (r.status || 400));
   }
   if (p === '/api/validate/plan' && req.method === 'POST') {