create-pmos 0.72.1 → 0.74.0

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

@@ -0,0 +1,137 @@
+/* pm/note-dock.js — the meeting note being taken, kept small at the bottom right of the workspace (meeting-notes Run 6).
+ *
+ * Take notes on a calendar event makes the note and starts listening at once. The note stays minimized as a pill at the
+ * bottom right: a red dot while it listens, its title and its time. A press on the pill 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 back; Open in Notes shows it
+ * on the full screen. The pill stays on every destination.
+ *
+ * One note at a time. The note is kept in this browser (KEY), so it is still there after a reload; a note that no longer
+ * listens can be put away with the x. Starting another note while one is listening asks first.
+ *
+ *   mountDock()                → draws the dock on every render (pm/app.js boot)
+ *   takeNotes(e, opts, btn)    → makes a note linked to the event, starts listening, and keeps it minimized
+ *   openDock(id)               → shows a note in the pop-up
+ *   minimize() · activeId()
+ */
+import { el } from './dom.js';
+import { button, iconButton, layer, toast, ensureComponentsCss } from './primitives.js';
+import { askConfirm } from './dialogs.js';
+import { pmPost } 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;
+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 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 function mountDock() {
+  if (host || FIXTURE || typeof document === 'undefined') return;
+  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(); });
+}
+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;
+}
+
+/** 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);
+  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;
+  if (!active || !v) { host.replaceChildren(); return; }
+  if (live) tick = setInterval(() => { const c = host.querySelector('[data-nt-dock-clock]'); if (c) c.textContent = clockText(); }, 1000);
+  if (!open) {
+    const pill = button({ label: el('span', { class: 'nt-pill__txt' },
+      live ? el('span', { class: 'nt-live-dot', 'aria-hidden': 'true' }) : null,
+      el('span', { class: 'nt-pill__title' }, titleOf()),
+      live ? el('span', { class: 'nt-pill__clock', 'data-nt-dock-clock': '' }, clockText()) : null),
+    variant: 'outline', attrs: { class: 'nt-pill', 'data-nt-pill': live ? 'live' : 'idle', 'aria-label': (live ? 'Notes are being taken: ' : 'Meeting note: ') + titleOf() + '. Open the note.' },
+    onClick: () => openDock(active.id) });
+    host.replaceChildren(el('div', { class: 'nt-pillrow' }, pill,
+      live ? null : iconButton({ icon: 'x', ariaLabel: 'Put the note away', onClick: close, attrs: { 'data-nt-dock-close': '' } })));
+    return;
+  }
+  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 },
+    el('div', { class: 'nt-pop__head' }, el('span', { class: 'nt-sec__h' }, live ? 'Taking notes' : 'Meeting note'),
+      button({ label: 'Minimize', variant: 'ghost', size: 'sm', onClick: minimize, attrs: { 'data-nt-minimize': '' } })),
+    body);
+  host.replaceChildren(pop);
+  if (!v.renderInline(body, viewCtx, active.id)) body.appendChild(el('p', { class: 'nt-hint' }, 'Another note is being taken.'));
+}

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

@@ -2,27 +2,26 @@
  *
  *   notesFor(e)                    → the note rows linked to a calendar event (same id, or same start minute and title)
  *   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 and runs it right there (typing and listening, pm/view-notes.js renderInline);
- *                                    an event that has a note shows its summary and Open notes, which opens it there too
+ *                                    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
  *   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
  *
  * One read feeds it: GET /api/notes (a row carries the meeting, the initiative and up to three summary lines, never the body;
- * a private note carries its title only). Take notes writes POST /api/notes/new { meeting, initiative }.
+ * a private note carries its title only). Take notes (pm/note-dock.js) writes POST /api/notes/new { meeting, initiative }.
  */
 import { el } from './dom.js';
 import { button } from './primitives.js';
-import { pmGet, pmPost } from './http.js';
-import { state, setState, FIXTURE } from './state.js';
+import { pmGet } from './http.js';
+import { takeNotes, openDock, activeId } from './note-dock.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;
 const subs = new Set();
-let shown = null;            // the note open in an event's detail (Take notes or Open notes); the listening note is shown too
-let V = null;                // pm/view-notes.js, read the first time a note is shown in a detail
-const viewCtx = { state, setState, FIXTURE };
 
 export function onNotes(fn) { subs.add(fn); return () => subs.delete(fn); }
 export function refreshNotes() {
@@ -51,6 +50,7 @@ export function sameEvent(meeting, e) {
 export const notesFor = (e) => list().filter((n) => sameEvent(n.meeting, e));
 export const notesOfInitiative = (id) => list().filter((n) => n.initiative && n.initiative.id === id);
 export const notesKnown = () => rows !== null || failed;
+export const noteById = (id) => (rows || []).find((n) => n.id === id) || null;
 
 /** The meeting link a calendar event gives a note. */
 export function meetingOf(e) {
@@ -63,22 +63,6 @@ export async function openNote(id) {
   v.openNote(id);
   c.openView('notes');
 }
-async function takeNotes(e, { ws, repo, initiative } = {}, btn) {
-  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) { const { toast } = await import('./primitives.js'); toast({ text: (r && r.error) || 'The note was not made.', tone: 'destructive' }); return; }
-  shown = r.note.id;
-  await refreshNotes();
-  setState({});
-}
-function show(id) { shown = id; setState({}); }
-function view() {
-  if (!V) import('./view-notes.js').then((m) => { V = m; setState({}); });
-  return V;
-}
-
 const dayOf = (iso) => { try { return new Date(iso).toLocaleDateString([], { weekday: 'short', day: 'numeric', month: 'short' }); } catch { return ''; } };
 const clock = (iso) => { try { return new Date(iso).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); } catch { return ''; } };
 
@@ -88,30 +72,25 @@ export function notesBlock(e, opts = {}) {
   const ended = !!e.ended;
   if (mine.length) {
     const n = mine[0];
-    const v = view();
-    const live = v && v.listeningId() === n.id;
-    if (v && (shown === n.id || live)) {
-      const host = el('div', { class: 'td-day__notes nt-inhost', 'data-notes-block': 'inline', 'data-notes-id': n.id });
-      const head = el('div', { class: 'nt-inhost__head' }, el('h4', null, 'Meeting notes'),
-        live ? null : button({ label: 'Close', variant: 'ghost', size: 'sm', attrs: { 'data-notes-close': n.id }, onClick: () => show(null) }));
-      host.appendChild(head);
-      if (v.renderInline(host, viewCtx, n.id)) return host;
-    }
     const lines = n.summary_lines || [];
-    const busy = v && v.listeningId() && v.listeningId() !== n.id;
+    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('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 },
       el('h4', null, 'Meeting notes'),
       n.private ? el('p', { class: 'td-day__note' }, 'This note is private.')
         : lines.length ? el('ul', { class: 'nt-lsum' }, ...lines.map((l) => el('li', null, l)))
           : el('p', { class: 'td-day__note' }, n.segments ? 'No summary yet. Open the note and press Summarize.' : 'No summary yet.'),
-      busy ? el('p', { class: 'td-day__note', 'data-notes-busy': '' }, 'Another meeting is being listened to. Stop it first to open this note here.') : null,
-      busy ? null : el('div', { class: 'td-day__acts' }, button({ label: 'Open notes', size: 'sm', attrs: { 'data-notes-open': n.id }, onClick: () => show(n.id) })));
+      el('div', { class: 'td-day__acts' }, button({ label: 'Open notes', size: 'sm', attrs: { 'data-notes-open': n.id }, onClick: () => openDock(n.id) })));
   }
   if (!notesKnown()) return null;
   const take = button({ label: 'Take notes', variant: ended ? undefined : 'primary', size: 'sm', attrs: { 'data-notes-take': e.id || '' }, onClick: () => takeNotes(e, opts, take) });
   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 here when the meeting starts. The note 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 keeps the note at the bottom right. It is linked to this event' + (opts.initiative ? ' and its initiative.' : '.')),
     el('div', { class: 'td-day__acts' }, take));
 }
 

package/workspace/public/pm/today-copy.js

@@ -159,7 +159,7 @@ export const COPY = {
     all: 'All',
     status2: {
       waiting: 'waiting', working: 'agent working', review: 'approve', reviewAuto: 'check it', sending: 'sending', sent: 'sent',
-      done: 'done', failed: 'failed', you: 'your act', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
+      done: 'done', failed: 'failed', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
     },
     newItem: 'new',
     pill: { prepare: 'prepare', ready: 'ready', ended: 'ended', notes: 'notes', goal: (n) => `goal ${n}` },
@@ -189,8 +189,6 @@ export const COPY = {
     prep: 'Prepare',
     phases: { before: 'Before', during: 'During', after: 'After' },
     who: { pm: 'you', agent: 'agent' },
-    needPrep: 'You need to prepare',
-    nothingToPrep: 'Nothing to prepare',
     initiative: 'Initiative',
     suggested: (why) => `Suggested. ${why}`,
     openInitiative: 'Open the initiative',
@@ -235,7 +233,6 @@ export const COPY = {
     waitingNote: 'The agent has not started this job yet. At most 5 sessions run at once.',
     workingNote: 'An agent session is doing this job now.',
     sendingNote: 'You said yes to this draft. An agent session is sending it now.',
-    youNote: 'Only you can do this one. The link opens the conversation.',
     autoNote: 'The agent did this alone. Nothing went outside this machine.',
     notTask: 'The agent starts this job when you press Prepare my day.',
     related: 'Related',
@@ -351,6 +348,87 @@ export const COPY = {
       today: 'Today',
     },
   },
+  /** The items the PM acts on and the meetings the PM prepares for (initiative today-act-prepare, PRD A1 to D4). A verb
+   *  first, one sentence of what to do, then the steps, one button that fits the first open step, and the marks. */
+  act: {
+    verb: { reply: 'Reply', review: 'Review', decide: 'Decide', 'sign-off': 'Sign off', read: 'Read', do: 'Do', prepare: 'Prepare', approve: 'Approve' },
+    groups: { later: 'Snoozed', waiting: 'Waiting on others', done: 'Done today' },
+    by: (at) => `by ${at}`,
+    at: (at) => `at ${at}`,
+    left: (min) => (min <= 0 ? 'now' : min < 60 ? `in ${min} min` : `in ${Math.floor(min / 60)} h ${min % 60} min`),
+    back: (at) => `back ${at}`,
+    check: (at) => `ask ${at}`,
+    chip: { done: 'done', ready: 'ready', dismissed: 'not mine', skipped: 'no prep', today: 'today' },
+    from: (who, where) => (who && where ? `${who} in ${where}` : who || where || ''),
+    howTitle: (d, n) => `How to do it · ${d} of ${n}`,
+    beforeTitle: (at) => `Before ${at}`,
+    more: 'More context',
+    moreMeeting: (during, after) => `In the meeting (${during}) · After (${after})`,
+    readOnly: 'Read only. Nothing is sent before you press a button that says so.',
+    open: { slack: 'Reply in Slack ↗', jira: 'Open in Jira ↗', confluence: 'Open in Confluence ↗', github: 'Open on GitHub ↗', figma: 'Open in Figma ↗',
+      mail: 'Open the mail ↗', drive: 'Open in Google Drive ↗', calendar: 'Open the event ↗', wispr: 'Open the notes ↗', website: 'Open the page ↗' },
+    openLink: 'Open the link ↗',
+    startStep: (t) => `Start: ${t}`,
+    askAgentStep: 'Ask the agent',
+    draft: 'Have the agent draft it',
+    drafting: 'The agent is drafting. The draft shows here, and nothing is sent before you approve it.',
+    draftStarted: 'The agent is drafting it. Approve or revise the draft when it is ready.',
+    done: 'Mark done',
+    ready: 'Mark ready',
+    snooze: 'Snooze',
+    remind: 'Remind me',
+    hold: 'Waiting on…',
+    notMine: 'Not mine',
+    skip: 'Skip prep',
+    snoozeTo: { hour: 'In 1 hour', later: 'Later today, 16:00', due: 'Before it is due', end: 'End of the day, 17:30', m30: '30 min before it', m15: '15 min before it' },
+    holdWho: 'Who or what you wait on',
+    holdHint: 'For example: Raj, or the cost model',
+    holdWhen: 'Ask again',
+    holdWhenOpts: { h2: 'In 2 hours', end: 'At 17:30' },
+    holdGo: 'Put on hold',
+    holdNeed: 'Say who or what you wait on, in 1 to 80 characters.',
+    why: { 'no-action': 'No action needed', 'someone-else': 'Someone else handles it', 'done-elsewhere': 'It is already done', nothing: 'Nothing to prepare', elsewhere: 'I prepare elsewhere' },
+    did: {
+      done: (t) => `Done: ${t}.`, ready: (t) => `Ready: ${t}.`, snooze: (at) => `Snoozed. It comes back at ${at}.`,
+      hold: (who, at) => `Waiting on ${who}. Today asks you again at ${at}.`, dismiss: (why) => `${why}. Taken off Needs you.`, reopen: 'Back in Needs you.',
+    },
+    undo: 'Undo',
+    undone: 'Put back as it was.',
+    state: {
+      snoozed: (at) => `Snoozed. It comes back to Needs you at ${at}.`,
+      waiting: (who, at) => `On hold: waiting on ${who}. Today asks you again at ${at}.`,
+      done: (at) => `Done at ${at}.`, ready: (at) => `Ready at ${at}.`,
+      dismissed: (why) => `Not on your list: ${why}.`,
+      back: 'Back from snooze or hold: the time you set has come.',
+    },
+    bringBack: 'Bring it back now',
+    reopen: 'Reopen',
+    readiness: (d, n) => `${d} of ${n} ready`,
+    fit: { ok: 'Your prep is done.', time: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left, ${free} min free before it.`,
+      short: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left and ${free} min free. Give a step to the agent, or snooze.` },
+    noSteps: 'No steps were given. The sentence above says what to do.',
+    stepFailed: (why) => `The step was not saved: ${why}`,
+    // the context and the answer in the card (PRD X1, X2, F1 to F3)
+    threadTitle: 'The conversation',
+    refsTitle: 'What the sources say',
+    refRead: 'Read: ',
+    refOpen: 'Open the source ↗',
+    compose: { reply: 'Your reply', review: 'Your review', decide: 'Your answer', 'sign-off': 'Your sign-off' },
+    composeHint: 'Write it here, or start from a suggestion.',
+    startFrom: 'Start from:',
+    verdictLabel: 'Your verdict',
+    verdict: { approve: 'Approve', changes: 'Ask for changes' },
+    sendTo: (to) => `Send to ${to}`,
+    postReview: (to) => `Post the review to ${to}`,
+    sendNote: 'When you press, the agent posts exactly this text, as you, to that place. Nothing else is sent.',
+    sendNeed: 'Write the text to send first.',
+    verdictNeed: 'Choose Approve or Ask for changes first.',
+    sendStarted: (to) => `Sending to ${to}. The job shows Sent when it is posted.`,
+    noteTitle: 'Your note',
+    noteHint: 'Write it here. It is saved when you leave the box.',
+    noteStays: 'Saved with the meeting on this machine. Nothing is sent.',
+    noteSaved: 'Note saved.',
+  },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {
     review: 'Review',