create-pmos 0.72.1 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.72.1",
+  "version": "0.73.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@cf1223e
+kernel-source: pmos@a99e09f
 assembled: 2026-10-07
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:41:12Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:41:12Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-07T05:22:25Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T05:41:12Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -95,7 +95,7 @@ Under the title, a note shows two lines: **Meeting** and **Initiative**.
 
 When a note has no initiative, the summary suggests one: the open initiative that shares 3 or more words with what was said, when no other initiative shares as many. A suggestion never replaces an initiative you chose.
 
-To take notes for a calendar event, open the event's detail on the Agenda and press **Take notes**. The note is linked to the event, and to the event's initiative when it has one. The note opens inside the event's detail, in one column: type your notes, press **Listen**, and read the transcript there, without leaving the calendar. Press **Open in Notes** to see the same note on the full screen, and **Close** to fold it back to its summary. An event that already has a note shows its summary and **Open notes**, which opens the note in the detail. While one meeting is being listened to, another event's detail shows only its summary, so the meeting that is being heard is not stopped. See [Today](today.md) and [the initiative sheet](initiatives-screen.md).
+To take notes for a calendar event, open the event's detail on the Agenda and press **Take notes**. PMOS starts to listen at once, to your microphone and to the meeting when local transcription is set up. Pick the meeting's tab or window when the browser asks. Let people know that you are taking notes. The note is linked to the event, and to the event's initiative when it has one. The note stays small at the bottom right of the workspace, with a red dot, its title and its time, on every page. Press it to open the note as a pop-up: type your notes, read the transcript, and press **Stop** when the meeting ends. Press **Minimize** or Esc to make it small again, and **Open in Notes** to see it on the full screen. One note is taken at a time. If you press **Take notes** on another event while a note listens, PMOS asks first: **Keep it**, or **Stop it and start this one**. The note stays at the bottom right after a reload. When it no longer listens, press the x beside it to put it away. An event that already has a note shows its summary and **Open notes**, which opens the note in the pop-up. See [Today](today.md) and [the initiative sheet](initiatives-screen.md).
 
 ## Dictate into your notes
 

package/workspace/guide/today.md

@@ -50,7 +50,7 @@ Each day of the month answers three questions:
 
 The switch above the month shows one answer at a time: **Overview** (all three), **Full** (the time in meetings), **Key** (the meeting that matters), **Prep** (how ready you are) or **Free** (the free blocks of 90 minutes or more).
 
-A meeting's detail ends with **Meeting notes**. Press **Take notes** to start a note linked to the meeting, and to its initiative when the brief names one. The note runs in the detail: you type and listen there. **Open in Notes** shows it on the full screen. When the meeting has a note, the detail shows its summary and **Open notes**, which opens it in the detail again, and the meeting's row shows **notes**. See [Notes](notes.md).
+A meeting's detail ends with **Meeting notes**. Press **Take notes** to start a note linked to the meeting, and to its initiative when the brief names one. PMOS starts to listen at once and keeps the note small at the bottom right. Press it to open the note as a pop-up. When the meeting has a note, the detail shows its summary and **Open notes**, which opens it in the pop-up, and the meeting's row shows **notes**. See [Notes](notes.md).
 
 The memory of a meeting says what kind of meeting it is (one-to-one, onboarding or group), how many times it was held, how many are to come, and why it matters.
 

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.72.1",
+  "version": "0.73.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.72.1",
+  "version": "0.73.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/app.js

@@ -776,6 +776,8 @@ async function boot() {
       if (FRAME) { reg.setFrameHome((id, p) => go(id, p)); fr.reg = reg; }   // the frame: pmApp.open(id) is the place on screen
     }
     catch (e) { console.error('[pm] the registry failed to load:', e); }
+    // meeting-notes Run 6: the note being taken stays at the bottom right on every destination
+    import('./note-dock.js').then((m) => m.mountDock()).catch((e) => console.error('[pm] the note dock failed to load:', e));
     render();
   }
 }

package/workspace/public/pm/components.css

@@ -6212,13 +6212,7 @@
   color: var(--muted-foreground);
 }
 
-/* meeting-notes Run 5: the note runs inside a calendar event's detail, in one column */
-.nt-inhost__head {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 8px;
-}
+/* meeting-notes Runs 5 and 6: the note in one column, as the pop-up draws it */
 .nt-wrap--inline .nt-body2 {
   grid-template-columns: 1fr;
 }
@@ -6232,7 +6226,70 @@
   border-top: 1px solid var(--border);
 }
 .nt-wrap--inline .nt-lines {
-  max-height: 320px;
+  max-height: 240px;
+}
+
+/* meeting-notes Run 6: the note being taken, minimized at the bottom right, and its pop-up */
+.nt-dock {
+  position: fixed;
+  right: 16px;
+  bottom: 40px;
+  z-index: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+}
+.nt-dock:empty {
+  display: none;
+}
+.nt-pillrow {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+}
+.nt-pill {
+  max-width: 320px;
+  background: var(--card);
+  box-shadow: 0 4px 16px color-mix(in oklab, var(--term-bg) 18%, transparent);
+}
+.nt-pill__txt {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+.nt-pill__title {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.nt-pill__clock {
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+  color: var(--muted-foreground);
+}
+.nt-pop {
+  width: min(440px, calc(100vw - 32px));
+  max-height: calc(100vh - 120px);
+  display: flex;
+  flex-direction: column;
+  border: 1px solid var(--border);
+  background: var(--card);
+  box-shadow: 0 12px 40px color-mix(in oklab, var(--term-bg) 24%, transparent);
+}
+.nt-pop__head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--border);
+}
+.nt-pop__body {
+  min-height: 0;
+  overflow-y: auto;
+  padding: 12px;
 }
 
 /* -- layouts · .lg- the legacy and fixture shells (Run 3, slice 3D) -- */

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/view-notes.js

@@ -1,4 +1,4 @@
-/* pm/view-notes.js — the Notes view tab: one meeting on one screen (meeting-notes, Runs 1 to 5).
+/* pm/view-notes.js — the Notes view tab: one meeting on one screen (meeting-notes, Runs 1 to 6).
  *
  * The screen follows the simplified mockup the PM reviewed (prototype/meeting-notes):
  *   header      the title and the date, and one action: Listen; while listening a red dot, the time, the sources and Stop;
@@ -28,8 +28,10 @@
  * calendar) and which initiative it belongs to, and how that was set: from the calendar event, suggested from what was said,
  * or chosen by the PM. Change opens a sheet for each.
  *
- * IN THE EVENT'S DETAIL (Run 5). renderInline draws the same note inside a calendar event's detail (pm/notes-links.js), in
- * one column: the PM types and listens there without leaving the calendar. Open in Notes shows it on the full screen.
+ * MINIMIZED AT THE BOTTOM RIGHT (Run 6). Take notes on a calendar event starts listening at once (listenNow: no chooser) and
+ * keeps the note as a pill at the bottom right (pm/note-dock.js). The pill opens the note as a pop-up, which renderInline
+ * draws in one column. While the pop-up shows a note, the Notes tab says so and does not draw it a second time.
+ * Open in Notes shows it on the full screen.
  *
  * Reads and writes (lib/routes-notes.js). Notes live in the per-user runtime directory, never in a repository:
  *   GET  /api/notes · /api/notes/one?id=… · /api/notes/engine?ws=… · /api/notes/recording?id=… · /api/people?ws=…
@@ -67,7 +69,8 @@ let busy = '';
 let player = null;            // the replay: { id, bytes, el, playing }, kept across redraws so playback goes on
 let people = null;            // { ws, names } — the repository's people, offered in the line editor
 let pendingOpen = null;       // a note another page asked to open (openNote), selected at the next draw
-let inlineSwitch = null;      // the note an event's detail is switching to (renderInline), so a redraw does not start it twice
+let inlineSwitch = null;      // the note the pop-up is switching to (renderInline), so a redraw does not start it twice
+let popped = null;            // the note the pop-up shows (pm/note-dock.js), which the Notes tab then does not draw
 const LABELS = [['decision', 'Decision'], ['action', 'Action'], ['question', 'Question'], ['fact', 'Fact'], ['topic', 'Topic'], ['statement', 'Statement'], ['small talk', 'Small talk']];
 
 const nowClock = (iso) => { try { return new Date(iso).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); } catch { return ''; } };
@@ -1021,7 +1024,12 @@ export function renderBoard(inner, ctx) {
   if (banner) wrap.appendChild(el('div', { class: 'nt-banner' + (banner.tone === 'bad' ? ' nt-banner--bad' : ''), 'data-nt-banner': banner.tone, role: banner.tone === 'bad' ? 'alert' : 'status' }, banner.text));
   const n = currentId ? cache.get(currentId) : null;
   if (currentId && !n) { loadNote(ctx, currentId); wrap.appendChild(el('p', { class: 'nt-hint' }, 'reading the note …')); }
-  else if (!n) {
+  else if (n && popped === n.id) {
+    wrap.appendChild(el('div', { class: 'nt-start', 'data-nt-popped': '' },
+      el('h2', { class: 'nt-h' }, n.title || 'Untitled note'),
+      el('p', { class: 'nt-hint' }, 'This note is open in the pop-up at the bottom right.'),
+      button({ label: 'Show it here', variant: 'primary', onClick: () => openFull(ctx, n.id), attrs: { 'data-nt-unpop': '' } })));
+  } else if (!n) {
     wrap.appendChild(el('div', { class: 'nt-start' },
       el('h2', { class: 'nt-h' }, 'Notes'),
       el('p', { class: 'nt-hint', 'data-nt-about': '' }, 'Take notes in a meeting. PMOS listens on this machine, catches the decisions, actions and questions, and checks them against your repository. No audio leaves this machine, and notes are kept outside every repository.'),
@@ -1055,17 +1063,39 @@ function keepFocus() {
 }
 async function openFull(ctx, id) {
   await flushSave(ctx);
-  const c = await import('./panel-cockpit.js');
+  popped = null;
+  const [c, d] = await Promise.all([import('./panel-cockpit.js'), import('./note-dock.js')]);
+  d.minimize();
   pendingOpen = id;
   c.openView('notes');
 }
 
+/** The note the pop-up shows (pm/note-dock.js), or null. */
+export function setPopped(id) { popped = id || null; }
+/** The note's title as last read or typed, or ''. */
+export const titleOf = (id) => (editor && editor.id === id && editor.title.value.trim()) || ((cache.get(id) || {}).title) || '';
+/** When the note that is listening started, or null. */
+export const liveStarted = () => (audio && audio.state === 'on' ? audio.started : speech && speech.mode === 'record' && speech.state === 'on' ? speech.started : null);
+/** Stop the note that is listening, as its Stop does. */
+export const stopListening = (ctx) => stopRecording(ctx);
+/** Start listening on this note at once, with no chooser (Run 6, Take notes): the microphone and the meeting when Whisper is set
+ * up, else the microphone through the browser's on-device recognition. False when the note cannot listen (private, gone). */
+export async function listenNow(ctx, id) {
+  if (id !== currentId) await selectNote(ctx, id);
+  let n = cache.get(id);
+  if (!n) { await loadNote(ctx, id); n = cache.get(id); }
+  if (!n || n.private) return false;
+  const eng = engine && engine.ws === wsOf(ctx) && engine.whisper ? engine : await loadEngine(ctx);
+  if (eng.whisper && eng.whisper.ready) await startAudio(ctx, n, ['mic', 'meeting']); else await startSpeech(ctx, n, 'record');
+  return listeningId() === id;
+}
+
 /** The note that is listening now, or null. */
 export const listeningId = () => (audio && audio.id) || (speech && speech.mode === 'record' && (speech.state === 'on' || speech.state === 'checking') ? speech.id : null);
 
-/** One note drawn inside a calendar event's detail (meeting-notes Run 5): the same note, editor and listening as the Notes
- * tab, in one column, with Open in Notes for the full screen. It never stops a meeting that is being heard: when another note
- * is listening it draws nothing and returns false. */
+/** One note drawn in the pop-up (meeting-notes Run 6, pm/note-dock.js): the same note, editor and listening as the Notes tab,
+ * in one column, with Open in Notes for the full screen. It never stops a meeting that is being heard: when another note is
+ * listening it draws nothing and returns false. */
 export function renderInline(host, ctx, id) {
   if (ctx.FIXTURE) return false;
   const other = listeningId();