create-pmos 0.116.0 → 0.118.0

package/workspace/public/pm/note-dock.js

@@ -1,200 +1,240 @@
-/* pm/note-dock.js — the meeting note being taken: the Record control's brain and the pop-up (meeting-notes Run 6, Run 12).
+/* pm/note-dock.js — the meeting being recorded: the Record control's brain (meeting-notes Run 13).
  *
- * The Record control lives in the top bar (pm/topbar.js, mockup board 2): Record when idle, the red dot with the clock, the
- * highlighter and Pause while listening, Resume when paused. Take notes on a calendar event makes the note and starts
- * listening at once. A press on the clock opens the note as a pop-up: the same note as the Notes tab, in one column
- * (pm/view-notes.js renderInline). Minimize or Esc puts it away; the highlight pop-up sits bottom right on every place.
+ * The Record control lives in the top bar (pm/topbar.js). It has two groups. The left one exists while a meeting is recording
+ * or paused: a chip that names the meeting, then Highlight, Pause and Stop (recording) or Resume and Stop (paused). The right
+ * one is always there: New, which starts an untitled note, and an arrow that lists today's meetings that have not started.
+ * There is no pop-up note any more: the chip, and every start of a recording, show the Notes place with that note selected,
+ * and the note there is the full note (pm/dest-notes.js).
  *
- * One note at a time. The note is kept in this browser (KEY), so it is still there after a reload. Starting another note
- * while one is listening asks first.
+ * PAUSE keeps the meeting open and resumable for an hour (the server ends it by itself after that and writes the final
+ * notes). STOP ends it for good, asks first, and writes the final notes now. A stopped meeting cannot be resumed. A note
+ * that is stopped within a minute, or before anything was heard, with nothing typed, is deleted instead (a recording started
+ * by mistake must not take the place of the meeting before it). Resume applies to the most recent meeting only.
  *
- *   mountDock()                → draws the dock on every render (pm/app.js boot)
- *   recordState()              → { mode: idle | recording | paused, id, title, started } for the top bar
- *   recordNew(btn) · recordNote(id, title) · pauseNow() · resumeNow() · finish() · highlightNow()
- *   takeNotes(e, opts, btn)    → makes a note linked to the event, starts listening
- *   openDock(id)               → shows a note in the pop-up
- *   minimize() · activeId() · forget(id)
+ * What is held is read, not remembered: the listening note comes from pm/view-notes.js, and a paused meeting from the note
+ * rows (GET /api/notes: state, resume_until, sessions), read again every REREAD_MS and after each action.
+ *
+ *   mountDock()                  → reads the rows now and then every REREAD_MS (pm/app.js boot)
+ *   recordState()                → { mode: idle | recording | paused, id, title, started, until } for the top bar
+ *   recordNew(btn) · recordEvent(e, btn) · takeNotes(e, opts, btn) · recordNote(id, title)
+ *   pauseNow() · resumeNow() · stopNow() · highlightNow() · highlightPanel()
+ *   openDock(id)                 → shows the note in the Notes place
+ *   activeId() · forget(id)
  */
-import { el, patchChildren } from './dom.js';
-import { button, iconButton, layer, toast, ensureComponentsCss } from './primitives.js';
-import { askConfirm } from './dialogs.js';
-import { pmPost } from './http.js';
+import { sheet, button, toast, ensureComponentsCss } from './primitives.js';
+import { el } from './dom.js';
+import { pmPost, pmGet } from './http.js';
 import { state, setState, subscribe, FIXTURE } from './state.js';
-import { meetingOf, refreshNotes, noteById } from './notes-links.js';
-
-const KEY = 'pmos.workspace.pm.note';
-let active = read();          // { id, title }: the one note in the dock
-let open = false;             // the pop-up is open
-let host = null;
-let V = null;                 // pm/view-notes.js, read the first time the dock draws a note
-let tick = null;
+import { meetingOf, refreshNotes, noteById, notesRows, onNotes } from './notes-links.js';
+
+const REREAD_MS = 30000;
+const MIN = 60000;
+let V = null;                 // pm/view-notes.js, read the first time it is needed
+let mounted = false;
 const viewCtx = { state, setState, FIXTURE };
 
-function read() {
-  try { const j = JSON.parse(localStorage.getItem(KEY) || 'null'); return j && typeof j.id === 'string' ? { id: j.id, title: String(j.title || '') } : null; } catch { return null; }
-}
-function write() {
-  try { if (active) localStorage.setItem(KEY, JSON.stringify(active)); else localStorage.removeItem(KEY); } catch { /* private mode: the note stays for this page */ }
-}
 function view() {
   if (!V) import('./view-notes.js').then((m) => { V = m; setState({}); });
   return V;
 }
+const loadView = async () => { if (!V) V = await import('./view-notes.js'); return V; };
 const liveId = () => (V ? V.listeningId() : null);
-const titleOf = () => { if (!active) return ''; const r = noteById(active.id); return (V && V.titleOf(active.id)) || (r && r.title) || active.title || 'Untitled note'; };
-
-export const activeId = () => (active ? active.id : null);
-export const isRecording = () => !!(active && V && liveId() === active.id);
 
 export function mountDock() {
-  if (host || FIXTURE || typeof document === 'undefined') return;
+  if (mounted || FIXTURE || typeof document === 'undefined') return;
+  mounted = true;
   ensureComponentsCss();
-  host = el('div', { class: 'nt-dock', 'data-nt-dock': '' });
-  // Esc in the pop-up minimizes it. It is read first (capture), so a field does not take it to undo the typing, and the shell
-  // does not also read it.
-  host.addEventListener('keydown', (e) => { if (e.key === 'Escape' && open) { e.preventDefault(); e.stopPropagation(); minimize(); } }, true);
-  const l = layer();
-  if (l) l.appendChild(host);
-  subscribe(draw);
-  if (active) view();
-  draw();
-}
-
-export function minimize() {
-  if (!open) return;
-  open = false;
-  if (V) V.setPopped(null);
-  setState({});
-}
-/** Show this note in the pop-up. Another note that is listening is asked about first. */
-export async function openDock(id) {
-  if (active && active.id !== id && liveId() === active.id && !await switchFrom()) { openDock(active.id); return; }
-  const r = noteById(id);
-  active = { id, title: (r && r.title) || '' }; write();
-  open = true;
-  const v = V || await import('./view-notes.js');
-  V = v; v.setPopped(id);
-  setState({});
-  requestAnimationFrame(() => { const t = host && host.querySelector('[data-nt-body]'); if (t) t.focus(); });
-}
-/** A note was deleted: when it is the one in the dock, the dock lets it go. */
-export function forget(id) {
-  if (!active || active.id !== id) return;
-  active = null; open = false; write();
-  if (V) V.setPopped(null);
-  setState({});
-}
-function close() {
-  if (liveId() === (active && active.id)) return;
-  active = null; open = false; write();
-  if (V) V.setPopped(null);
-  setState({});
-}
-/** Ask before a new note replaces the one that is listening. True when the PM stopped it. */
-async function switchFrom() {
-  const sure = await askConfirm({ title: '"' + titleOf() + '" is still being taken.', body: 'Only one note is taken at a time.', confirmLabel: 'Stop it and start this one', cancelLabel: 'Keep it' });
-  if (!sure) return false;
-  if (V) await V.stopListening(viewCtx);
-  return true;
+  // a meeting that was recording when the page closed is found again from the server
+  refreshNotes();
+  setInterval(() => refreshNotes(), REREAD_MS);
+  onNotes(() => setState({}));
+  subscribe(() => { if (!V && notesRows().some((n) => n.state === 'recording')) view(); });
 }
 
-/* ── the Record control at the right of the top bar (meeting-notes Run 12, mockup board 2) ────────────────────────────
- * It replaces the pill: idle it says Record; while the note listens it shows the red dot and the clock (a press opens the
- * note), the highlight and Pause; paused it shows the clock and Resume. Stop, in the note, ends it and the control is idle
- * again. The note it holds is the dock's one note (active). */
+/* ── what is held ─────────────────────────────────────────────────────────────────────────────────────────────────── */
 
-/** { mode: 'idle'|'recording'|'paused', id, title, started } — what the Record control shows. */
-export function recordState() {
-  if (!active) return { mode: 'idle', id: null, title: '', started: null };
-  const live = !!V && liveId() === active.id;
-  return { mode: live ? 'recording' : 'paused', id: active.id, title: titleOf(), started: live && V.liveStarted ? V.liveStarted() : null };
+/** The moment a note row was last recorded: the end of its last stretch, or now while a stretch is open. Pure. */
+export function lastRecorded(row, now = Date.now()) {
+  const s = (row && row.sessions) || [];
+  if (!s.length) return null;
+  const last = s[s.length - 1];
+  if (!last.to) return now;
+  const t = Date.parse(last.to);
+  return Number.isFinite(t) ? t : null;
+}
+/** The most recent recorded meeting among the rows. Pure. */
+export function lastMeeting(rows, now = Date.now()) {
+  let best = null; let at = -1;
+  for (const r of rows || []) {
+    const t = lastRecorded(r, now);
+    if (t !== null && t > at) { best = r; at = t; }
+  }
+  return best;
+}
+/** The paused meeting that Resume continues: the most recent one, while its hour has not run out. A row the server calls
+ * recording while this page listens to nothing is a meeting the page lost (a reload): it can be resumed, with no clock. Pure. */
+export function pausedOf(rows, { now = Date.now(), listening = null } = {}) {
+  const r = lastMeeting(rows, now);
+  if (!r || r.private) return null;
+  if (r.state === 'paused' && r.resume_until && Date.parse(r.resume_until) > now) return r;
+  if (r.state === 'recording' && listening !== r.id) return r;
+  return null;
 }
-/** Record: a new note, linked to nothing, that listens at once. */
-export async function recordNew(btn) {
-  if (active && liveId() === active.id) { openDock(active.id); return; }
+
+/** { mode: 'idle'|'recording'|'paused', id, title, started, until } — what the Record control shows. */
+export function recordState() {
+  const live = liveId();
+  if (live) return { mode: 'recording', id: live, title: titleOf(live), started: V && V.liveStarted ? V.liveStarted() : null, until: null };
+  const p = pausedOf(notesRows(), { listening: live });
+  if (p) return { mode: 'paused', id: p.id, title: p.title || 'Untitled note', started: null, until: p.resume_until ? Date.parse(p.resume_until) : null, ms: p.meeting_ms || 0 };
+  return { mode: 'idle', id: null, title: '', started: null, until: null };
+}
+const titleOf = (id) => { const r = noteById(id); return (V && V.titleOf(id)) || (r && r.title) || 'Untitled note'; };
+export const activeId = () => recordState().id;
+
+/* ── starting ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const blocked = () => { if (!liveId()) return false; toast({ text: 'Pause or stop the meeting being recorded first.' }); return true; };
+
+/** Make a note and listen at once; then show it in the Notes place. `body` is the POST /api/notes/new body. */
+async function startNote(body, btn) {
+  if (FIXTURE || blocked()) return false;
   if (btn) btn.disabled = true;
-  const r = await pmPost('/api/notes/new', {});
+  const r = await pmPost('/api/notes/new', body);
   if (btn) btn.disabled = false;
-  if (!r || !r.ok) { toast({ text: (r && r.error) || 'The note was not made.', tone: 'destructive' }); return; }
-  await recordNote(r.note.id, r.note.title || '');
-  refreshNotes();
+  if (!r || !r.ok) { toast({ text: (r && r.error) || 'The note was not made.', tone: 'destructive' }); return false; }
+  return begin(r.note.id);
 }
-/** Record or Resume on one note: it becomes the dock's note and listens. Another note that is listening is asked about first. */
-export async function recordNote(id, title) {
-  if (active && active.id !== id && liveId() === active.id && !await switchFrom()) return;
-  active = { id, title: title || '' }; write();
-  const v = V || await import('./view-notes.js');
-  V = v;
+async function begin(id) {
+  const v = await loadView();
+  refreshNotes();
+  const ok = await v.listenNow(viewCtx, id);
+  await refreshNotes();
+  openDock(id);
+  if (ok) toast({ text: 'Notes are being taken. Let people know.' });
+  else toast({ text: v.takeBanner() || 'The note could not listen.', tone: 'destructive' });
   setState({});
-  if (await v.listenNow(viewCtx, id)) toast({ text: 'Notes are being taken. Let people know.' });
+  return ok;
+}
+/** New: an untitled note, linked to nothing, that listens at once. */
+export function recordNew(btn) { return startNote({}, btn); }
+/** A meeting that has not started: a note made for its event, with its context kept. */
+export function recordEvent(e, btn) { return startNote({ meeting: meetingOf(e) }, btn); }
+/** Take notes on a calendar event (the calendar's own button): the note is linked to the event, and to its initiative when it has one. */
+export function takeNotes(e, { ws, repo, initiative } = {}, btn) {
+  const ini = initiative && initiative.id ? { id: initiative.id, ws: ws || null, repo: repo || null, title: initiative.title || null } : undefined;
+  return startNote({ meeting: meetingOf(e), ...(ini ? { initiative: ini } : {}) }, btn);
+}
+/** Record or Resume on one note (the legacy Notes board): a paused meeting resumes, any other note listens. */
+export async function recordNote(id) {
+  if (FIXTURE || blocked()) return false;
+  const v = await loadView();
+  const ok = await v.listenNow(viewCtx, id);
+  await refreshNotes();
+  if (!ok) toast({ text: v.takeBanner() || 'The note could not listen.', tone: 'destructive' });
   setState({});
+  return ok;
 }
-/** Pause: listening stops and the note stays here, ready to Resume. */
+
+/* ── pause, resume, stop ──────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** Pause: listening stops and the meeting stays open for an hour. It does not ask, and writes no final notes. */
 export async function pauseNow() {
-  if (V && active && liveId() === active.id) await V.stopListening(viewCtx);
+  await loadView();   // a meeting the Notes tab started is known to this page before the dock has read it
+  const s = recordState();
+  if (s.mode !== 'recording') return;
+  const v = await loadView();
+  await v.pauseListening(viewCtx);
+  await refreshNotes();
+  toast({ text: 'Paused. You can resume within 1 hour.', timeout: 3000 });
   setState({});
 }
-/** Resume the paused note. */
-export function resumeNow() { if (active) return recordNote(active.id, active.title); return null; }
-/** Stop: listening stops and the note leaves the Record control (the final notes are written after Stop). */
-export async function finish() {
-  if (V && active && liveId() === active.id) await V.stopListening(viewCtx);
-  active = null; open = false; write();
-  if (V) V.setPopped(null);
+/** Resume the paused meeting. The server refuses a meeting that was stopped or ran out of its hour. */
+export async function resumeNow() {
+  await loadView();
+  const s = recordState();
+  if (s.mode !== 'paused') return false;
+  const v = await loadView();
+  const ok = await v.listenNow(viewCtx, s.id);
+  await refreshNotes();
+  if (ok) toast({ text: 'Resumed ' + s.title + '. Let people know.' });
+  else toast({ text: v.takeBanner() || 'The meeting could not be resumed.', tone: 'destructive' });
   setState({});
+  return ok;
 }
+
+/** Is this note one that was started by mistake? Within a minute, or nothing heard, nothing typed, no highlight, one stretch. Pure. */
+export function discardable(n, now = Date.now()) {
+  if (!n || String(n.body || '').trim() || (n.highlights || []).length) return false;
+  const s = n.sessions || [];
+  if (s.length !== 1) return false;
+  const from = Date.parse(s[0].from); const to = s[0].to ? Date.parse(s[0].to) : now;
+  const heard = (n.transcript || []).some((x) => !x.dropped);
+  return !heard || to - from < MIN;
+}
+
+/** The "Stop for good?" pop-up. Resolves 'stop', 'pause' (only while recording) or null. */
+function askStop(title, recording) {
+  ensureComponentsCss();
+  return new Promise((resolve) => {
+    let settled = false; let handle = null;
+    const done = (v) => { if (settled) return; settled = true; resolve(v); if (handle) handle.close(); };
+    const actions = [button({ label: 'Cancel', variant: 'outline', onClick: () => done(null), attrs: { 'data-dialog-cancel': '' } })];
+    if (recording) actions.push(button({ label: 'Pause instead', variant: 'outline', onClick: () => done('pause'), attrs: { 'data-dialog-pause': '' } }));
+    actions.push(button({ label: 'Stop for good', variant: 'danger', onClick: () => done('stop'), attrs: { 'data-dialog-confirm': '' } }));
+    handle = sheet({ mode: 'auto', title: 'Stop “' + title + '” for good?',
+      body: [el('p', null, 'A stopped meeting cannot be resumed. The final notes are written now.'), recording ? el('p', null, 'Pause it instead if you may continue within an hour.') : null].filter(Boolean),
+      actions, attrs: { 'data-dialog': 'stop-meeting' }, onClose: () => done(null) });
+    const stopBtn = handle.dialog && handle.dialog.querySelector('[data-dialog-cancel]');
+    if (stopBtn) { try { stopBtn.focus({ preventScroll: true }); } catch { /* not focusable yet */ } }
+  });
+}
+
+/** Stop: asks first; ends the meeting for good. A recording started by mistake is deleted instead, without asking. */
+export async function stopNow() {
+  const v = await loadView();
+  const s = recordState();
+  if (s.mode === 'idle') return;
+  const one = await pmGet('/api/notes/one?id=' + encodeURIComponent(s.id));
+  const note = one && one.ok ? one.note : null;
+  if (note && discardable(note)) {
+    const gone = await v.discardRecording(viewCtx, s.id);
+    await refreshNotes();
+    const back = pausedOf(notesRows(), { listening: liveId() });
+    toast({ text: gone ? 'Nothing was recorded, so the note was deleted' + (back ? '. ' + (back.title || 'The earlier meeting') + ' can be resumed again.' : '.') : 'The note was not deleted.' });
+    setState({});
+    return;
+  }
+  const choice = await askStop(s.title, s.mode === 'recording');
+  if (choice === 'pause') { await pauseNow(); return; }
+  if (choice !== 'stop') return;
+  await v.stopMeeting(viewCtx, s.id);
+  await refreshNotes();
+  toast({ text: 'Stopped for good. The final notes are written now.' });
+  setState({});
+}
+/** Legacy name: the note's own Stop. */
+export const finish = stopNow;
+
 /** Highlight: the last 30 seconds and what is said next, on the note that is listening. */
 export function highlightNow() {
-  if (!V || !active || liveId() !== active.id) return;
-  V.highlightNow(viewCtx, active.id);
-}
+  const id = liveId();
+  if (!V || !id) return;
+  V.highlightNow(viewCtx, id);
+}
+/** The highlight's pop-up, for the top bar to hang under the Record control; null when there is none or it is closed. */
+export const highlightPanel = () => (V && V.highlightPanel ? V.highlightPanel(viewCtx) : null);
+export const highlightBusy = () => (V && V.highlightBusy ? V.highlightBusy() : null);
+export const viewReady = () => { view(); return !!V; };
 
-/** Take notes on a calendar event: make the note, start listening at once, and keep it minimized. */
-export async function takeNotes(e, { ws, repo, initiative } = {}, btn) {
-  if (active && liveId() === active.id && !await switchFrom()) { openDock(active.id); return; }
-  if (btn) btn.disabled = true;
-  const ini = initiative && initiative.id ? { id: initiative.id, ws: ws || null, repo: repo || null, title: initiative.title || null } : undefined;
-  const r = await pmPost('/api/notes/new', { meeting: meetingOf(e), ...(ini ? { initiative: ini } : {}) });
-  if (btn) btn.disabled = false;
-  if (!r || !r.ok) { toast({ text: (r && r.error) || 'The note was not made.', tone: 'destructive' }); return; }
-  active = { id: r.note.id, title: r.note.title || '' }; write();
-  open = false;
-  const v = V || await import('./view-notes.js');
-  V = v; v.setPopped(null);
+/** Show a note in the Notes place: the list by initiative, with this note open. */
+export async function openDock(id) {
+  const r = await import('./registry.js');
+  r.openDestination('notes', { slug: id });
+}
+/** A note was deleted: the Record control lets go of it. */
+export function forget(id) {
+  if (V && V.listeningId && V.listeningId() === id) { /* the view stops it */ }
   refreshNotes();
   setState({});
-  if (await v.listenNow(viewCtx, r.note.id)) toast({ text: 'Notes are being taken. Let people know.' });
-}
-
-function clockText() {
-  const s = V && V.liveStarted && V.liveStarted();
-  return s ? V.fmtTime(Date.now() - s) : '';
-}
-function draw() {
-  if (!host) return;
-  const v = view();
-  const live = !!active && !!v && liveId() === active.id;
-  clearInterval(tick); tick = null;
-  // The dock draws on every state change, and a transcript line comes in every few seconds while it listens. It draws into
-  // a detached node and patches the screen from it, so only what changed is touched: the lines already shown, the field
-  // being typed in, the scroll stay as they are, and a new line is appended (2026-10-08 flicker).
-  const fresh = el('div');
-  // the highlight's pop-up is drawn here, on every place, whether the note is open or not
-  const hl = v && v.highlightPanel ? v.highlightPanel(viewCtx) : null;
-  if (!active || !v) { if (hl) fresh.appendChild(hl); patchChildren(host, fresh); return; }
-  if (live) tick = setInterval(() => { const c = host.querySelector('[data-nt-dock-clock]'); if (c) c.textContent = clockText(); }, 1000);
-  // the Record control at the top right shows the note now (Run 12): no pill
-  if (!open) { if (hl) fresh.appendChild(hl); patchChildren(host, fresh); return; }
-  // the note draws its own bar (status, Stop, Minimize and the ⋯ menu): the pop-up adds no second head (Run 7)
-  const body = el('div', { class: 'nt-pop__body' });
-  const pop = el('section', { class: 'nt-pop', role: 'dialog', 'aria-label': 'Meeting note', 'data-nt-pop': active.id }, body);
-  fresh.appendChild(pop);
-  if (hl) fresh.appendChild(hl);
-  if (!v.renderInline(body, viewCtx, active.id, { onMinimize: minimize })) body.appendChild(el('p', { class: 'nt-hint' }, 'Another note is being taken.'),
-    button({ label: 'Minimize', variant: 'ghost', size: 'sm', onClick: minimize, attrs: { 'data-nt-minimize': '' } }));
-  // a transcript read to its end follows the new lines; one the PM scrolled up in stays where they left it
-  const box = host.querySelector('[data-nt-pop] [data-nt-transcript]');
-  const atEnd = !!box && box.scrollTop + box.clientHeight >= box.scrollHeight - 8;
-  patchChildren(host, fresh);
-  if (atEnd && box.isConnected) box.scrollTop = box.scrollHeight;
 }

package/workspace/public/pm/notes-context.js

@@ -0,0 +1,60 @@
+/* pm/notes-context.js — the context of a meeting, as a note keeps it (meeting-notes Run 13, R59).
+ *
+ *   contextOf(e)           → the snapshot a note stores when it is made for a calendar event, or null when the event gives nothing
+ *   peopleOf(ctx)          → the names in the "with" line, in order
+ *   agendaHeard(ctx, lines) → for each agenda item, the time of the first transcript line that shares two of its words, or null
+ *
+ * WHERE IT COMES FROM. The calendar memory and the morning brief (workspace/skills/morning-brief.skill) are the only sources:
+ * the event's "with" line (names, only while calendar names are on), the number of attendees, the PM's role, whether someone
+ * outside the company attends, the series, and the brief's plan for the meeting: its purpose, how to be ready, the steps
+ * planned for the meeting itself (the agenda), the links and the related items. The skill forbids copying an invitation's
+ * text, so there is no description or location here, and nothing is made up: a field the event does not carry is absent.
+ * The server clips and checks every field again (lib/notes.js cleanMeeting).
+ */
+
+const str = (v, max) => (typeof v === 'string' && v.trim() ? v.trim().slice(0, max) : null);
+const isUrl = (u) => typeof u === 'string' && /^https?:\/\//i.test(u);
+
+/** The snapshot of a calendar event's context. Pure. Null when the event carries none of it. */
+export function contextOf(e) {
+  if (!e || typeof e !== 'object') return null;
+  const prep = Array.isArray(e.prep) ? e.prep.map((x) => (x && typeof x === 'object' ? x.t : x)).filter((x) => typeof x === 'string').join(' · ') : e.prep;
+  const during = e.steps && Array.isArray(e.steps.during) ? e.steps.during : [];
+  const c = {
+    with: str(e.with, 120),
+    attendees: Number.isInteger(e.attendees) && e.attendees >= 0 ? e.attendees : null,
+    role: ['present', 'decide', 'attend'].includes(e.role) ? e.role : null,
+    external: e.external === true,
+    series: str(e.series, 200),
+    purpose: str(e.purpose, 240),
+    prep: str(prep, 240),
+    agenda: during.map((x) => str(x && typeof x === 'object' ? x.t : x, 140)).filter(Boolean).slice(0, 6),
+    links: (Array.isArray(e.links) ? e.links : []).filter((l) => l && isUrl(l.url)).slice(0, 5).map((l) => ({ label: str(l.label, 60) || 'Link', url: String(l.url).slice(0, 500) })),
+    refs: (Array.isArray(e.refs) ? e.refs : []).filter((r) => r && str(r.label, 120)).slice(0, 5).map((r) => ({ label: str(r.label, 120), source: str(r.source, 30), link: isUrl(r.link) ? String(r.link).slice(0, 500) : null })),
+  };
+  const any = c.with || c.attendees !== null || c.role || c.external || c.series || c.purpose || c.prep || c.agenda.length || c.links.length || c.refs.length;
+  return any ? c : null;
+}
+
+/** The names in a "with" line ("Ana, Budi and Citra"). Pure. */
+export function peopleOf(c) {
+  if (!c || !c.with) return [];
+  return String(c.with).split(/\s*(?:,|;|&|\band\b|\bdan\b)\s*/i).map((x) => x.trim()).filter(Boolean).slice(0, 12);
+}
+
+const STOP = new Set('the a an and or of to in on for with is are was be it this that we you i at by from as but not'.split(' '));
+const words = (s) => String(s || '').toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, ' ').split(/\s+/).filter((w) => w.length > 2 && !STOP.has(w));
+
+/** For each agenda item, when it was heard: the time (ms) of the first line that shares at least two of its words, else null.
+ * A local word match: the page says "heard", never "done". `lines` are { t, text }. Pure. */
+export function agendaHeard(c, lines) {
+  const items = (c && c.agenda) || [];
+  const ls = (lines || []).filter((l) => l && typeof l.text === 'string').map((l) => ({ t: typeof l.t === 'number' ? l.t : 0, w: new Set(words(l.text)) }));
+  return items.map((a) => {
+    const aw = [...new Set(words(a))];
+    const need = Math.min(2, aw.length);
+    if (!need) return null;
+    const hit = ls.find((l) => aw.filter((w) => l.w.has(w)).length >= need);
+    return hit ? hit.t : null;
+  });
+}

package/workspace/public/pm/notes-links.js

@@ -4,9 +4,9 @@
  *   notesOfInitiative(id)          → the note rows linked to an initiative, newest first
  *   noteById(id)                   → the note's row, or null
  *   notesBlock(e, { ws, repo, initiative }) → the "Meeting notes" block of an event's detail. Take notes makes a note linked
- *                                    to the event, starts listening and keeps the note minimized at the bottom right
- *                                    (pm/note-dock.js, Run 6); an event that has a note shows its summary and Open notes,
- *                                    which opens it as a pop-up
+ *                                    to the event, starts listening and shows the note in the Notes place
+ *                                    (pm/note-dock.js); an event that has a note shows its summary and Open notes,
+ *                                    which shows it in the Notes place
  *   noteRows(rows, { onOpen })     → the rows of an initiative's Notes tab; onOpen runs before the note opens
  *   openNote(id)                   → opens the Notes tab on that note
  *   onNotes(fn) · refreshNotes()   → redraw when the list is read
@@ -18,6 +18,7 @@ import { el } from './dom.js';
 import { button } from './primitives.js';
 import { pmGet } from './http.js';
 import { takeNotes, openDock, activeId } from './note-dock.js';
+import { contextOf } from './notes-context.js';
 
 const READ_MS = 15000;       // the list is read again at most this often while a calendar or an initiative is drawn
 let rows = null; let readAt = 0; let reading = null; let failed = false;
@@ -54,9 +55,34 @@ export const noteById = (id) => (rows || []).find((n) => n.id === id) || null;
 
 /** The meeting link a calendar event gives a note. */
 export function meetingOf(e) {
+  const context = contextOf(e);
   return { kind: 'event', event_id: /^[A-Za-z0-9_-]{1,40}$/.test(String(e.id || '')) ? String(e.id) : null, src: e.src === 'memory' ? 'memory' : 'brief',
-    start: e.start, end: e.end || null, title: e.title };
+    start: e.start, end: e.end || null, title: e.title, ...(context ? { context } : {}) };
 }
+export const notesRows = () => rows || [];
+
+/** Today's meetings that have not started and have no note yet, soonest first (the Record control's "upcoming" menu).
+ * Read from the Agenda: GET /api/proactive/agenda?month=… The answer is kept for UPCOMING_MS. */
+const UPCOMING_MS = 60000;
+let upcoming = null; let upcomingAt = 0; let upcomingReading = null;
+export function upcomingToday({ force = false } = {}) {
+  if (!force && upcoming && Date.now() - upcomingAt < UPCOMING_MS) return Promise.resolve(upcoming);
+  if (upcomingReading) return upcomingReading;
+  const d = new Date(); const pad = (n) => String(n).padStart(2, '0');
+  const day = d.getFullYear() + '-' + pad(d.getMonth() + 1) + '-' + pad(d.getDate());
+  // the Agenda gives the event; today's brief gives the plan for it (purpose, how to be ready, steps, links, related items)
+  upcomingReading = Promise.all([pmGet('/api/proactive/agenda?month=' + day.slice(0, 7)), pmGet('/api/proactive/today')]).then(([r, t]) => {
+    upcomingReading = null; upcomingAt = Date.now();
+    const evs = r && r.days && r.days[day] ? r.days[day].events || [] : [];
+    const cal = t && t.ok && t.brief && Array.isArray(t.brief.calendar) ? t.brief.calendar : [];
+    const planOf = (e) => cal.find((c) => minuteOf(c.start) === minuteOf(e.start) && normTitle(c.title) === normTitle(e.title));
+    const merged = evs.map((e) => { const p = planOf(e); return p ? { ...e, with: e.with || p.with, purpose: p.purpose, prep: typeof p.prep === 'string' ? p.prep : e.prep, steps: p.steps, links: p.links, refs: p.refs, initiative: p.initiative } : e; });
+    upcoming = merged.filter((e) => !e.ended && Date.parse(e.start) > Date.now()).sort((a, b) => String(a.start).localeCompare(String(b.start)));
+    return upcoming;
+  }).catch(() => { upcomingReading = null; return upcoming || []; });
+  return upcomingReading;
+}
+export const upcomingWithoutNote = (evs) => (evs || []).filter((e) => notesFor(e).length === 0);
 
 /** Open a note in the Notes place (meeting-notes Run 12): the list by initiative, with this note open. */
 export async function openNote(id) {
@@ -76,7 +102,7 @@ export function notesBlock(e, opts = {}) {
     if (activeId() === n.id) {
       return el('div', { class: 'td-day__notes', 'data-notes-block': 'docked', 'data-notes-id': n.id },
         el('h4', null, 'Meeting notes'),
-        el('p', { class: 'td-day__note' }, 'This note is open at the bottom right.'),
+        el('p', { class: 'td-day__note' }, 'This meeting is being recorded. The note is in Notes.'),
         el('div', { class: 'td-day__acts' }, button({ label: 'Open the note', size: 'sm', attrs: { 'data-notes-open': n.id }, onClick: () => openDock(n.id) })));
     }
     return el('div', { class: 'td-day__notes', 'data-notes-block': 'linked', 'data-notes-id': n.id },
@@ -98,7 +124,7 @@ export function notesBlock(e, opts = {}) {
   }
   return el('div', { class: 'td-day__notes', 'data-notes-block': 'none' },
     el('h4', null, 'Meeting notes'),
-    el('p', { class: 'td-day__note' }, ended ? 'No notes were taken in PMOS for this meeting.' : 'Take notes when the meeting starts. PMOS listens at once and keeps the note at the bottom right. It is linked to this event' + (opts.initiative ? ' and its initiative.' : '.')),
+    el('p', { class: 'td-day__note' }, ended ? 'No notes were taken in PMOS for this meeting.' : 'Take notes when the meeting starts. PMOS listens at once and shows the note in Notes. It is linked to this event' + (opts.initiative ? ' and its initiative.' : '.')),
     el('div', { class: 'td-day__acts' }, take));
 }
 

package/workspace/public/pm/primitives.js

@@ -356,7 +356,7 @@ export function menu({ anchor, items, ariaLabel } = {}) {
       ...(it.attrs || {}),
       type: 'button', role: it.role || 'menuitem', tabindex: '-1', class: cx('pmc-menu__item', it.danger && 'pmc-menu__item--danger'),
       onClick: (e) => { e.stopPropagation(); close(false); if (it.onSelect) it.onSelect(); },
-    }, it.iconNode || (it.icon ? icon(it.icon) : null), el('span', null, it.label), it.hint ? el('kbd', { class: 'pmc-menu__hint' }, it.hint) : null);
+    }, it.iconNode || (it.icon ? icon(it.icon) : null), el('span', { class: 'pmc-menu__text' }, it.label, it.detail ? el('small', { class: 'pmc-menu__detail' }, it.detail) : null), it.hint ? el('kbd', { class: 'pmc-menu__hint' }, it.hint) : null);
     btns.push(b); node.appendChild(b);
   }
   node.addEventListener('toggle', (e) => { if (e.newState === 'closed') close(false); });