create-pmos 0.74.0 → 0.76.0

package/workspace/public/pm/components.css

@@ -6326,6 +6326,148 @@
   padding: 12px;
 }
 
+/* meeting-notes Run 7: the note reads top to bottom (prototype/meeting-notes/simple-note-mockup.html). A bar with the state and
+   one action, the title, the day, the meeting and the initiative on one line, the people, then the sections, each item led by
+   its meeting time. The transcript folds away. The same column in the pop-up and on the full screen. */
+.nt-wrap:not(.nt-wrap--inline) {
+  max-width: 760px;
+}
+.nt-pop__body {
+  padding: 0 16px 16px;
+}
+.nt-header {
+  flex-direction: column;
+  align-items: stretch;
+  flex-wrap: nowrap;
+  gap: 8px;
+}
+.nt-bar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  min-height: 40px;
+  border-bottom: 1px solid var(--border);
+}
+.nt-wrap--inline .nt-bar {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: var(--card);
+}
+.nt-bar .nt-live {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.nt-bar .nt-acts {
+  flex: none;
+  flex-wrap: nowrap;
+  gap: 4px;
+}
+.nt-live b {
+  font-family: var(--sans);
+  font-weight: 500;
+}
+.nt-when .nt-link + .nt-link::before,
+.nt-when > span:first-child::after {
+  content: "·";
+  margin-right: 8px;
+  color: var(--muted-foreground);
+}
+.nt-when > span:first-child::after {
+  margin: 0 0 0 8px;
+}
+.nt-headl {
+  flex: none;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 4px;
+}
+.nt-when {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 4px 8px;
+}
+.nt-when .nt-link {
+  display: inline-flex;
+  align-items: center;
+  color: var(--foreground);
+}
+.nt-people {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.nt-avs {
+  display: inline-flex;
+  gap: 2px;
+}
+.nt-av {
+  width: 24px;
+  height: 24px;
+  display: inline-grid;
+  place-items: center;
+  font-size: 11px;
+  font-weight: 500;
+  color: var(--foreground);
+  background: var(--muted);
+}
+.nt-body2 {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.nt-notecol,
+.nt-wrap--inline .nt-notecol {
+  padding: 0;
+}
+.nt-trans,
+.nt-wrap--inline .nt-trans {
+  padding: 12px 0 0;
+  border-left: 0;
+  border-top: 1px solid var(--border);
+}
+.nt-fold {
+  cursor: pointer;
+}
+.nt-src {
+  font-weight: 400;
+  letter-spacing: normal;
+  text-transform: none;
+}
+.nt-item {
+  display: grid;
+  grid-template-columns: 44px minmax(0, 1fr) auto;
+  align-items: baseline;
+  border-bottom: 0;
+  padding: 2px 0;
+}
+.nt-item--plain {
+  grid-template-columns: minmax(0, 1fr) auto;
+}
+.nt-addrow {
+  display: grid;
+  grid-template-columns: 44px minmax(0, 1fr);
+  align-items: center;
+  gap: 8px;
+}
+.nt-addrow .nt-at {
+  font-variant-numeric: tabular-nums;
+}
+.nt-ln__meta .nt-at {
+  font-variant-numeric: tabular-nums;
+}
+.nt-spk--typed {
+  color: var(--foreground);
+  font-weight: 500;
+}
+
 /* -- layouts · .lg- the legacy and fixture shells (Run 3, slice 3D) -- */
 /* The legacy and fixture cockpit's two columns: the list head (a stack) and the rail's tile column. */
 .lg-stack {

package/workspace/public/pm/initiatives-api.js

@@ -12,7 +12,10 @@
  *   POST /api/initiatives      { ws, title, lane, anchor, intent?, from? }   the New-initiative form and a triage card (one body, no events)
  *   POST /api/initiatives/rescan { ws }                     the Re-scan press: read the repository again now (nothing is written)
  *   POST /api/initiatives/duplicates { ws }                 documents that share an initiative and a role (S10; nothing is written)
- *   POST /api/initiatives/tidy { ws, keep }                 move every other document of each kept group to the archive (S10)
+ *   POST /api/initiatives/tidy { ws, keep, kinds? }         record the kinds the PM confirmed (S11), then move every other
+ *                                                           document of each kept group to the archive (S10)
+ *   POST /api/initiatives/jev-check { ws, confirm?, … }     Jev's plan (nothing sent), or the PM-confirmed check: each
+ *                                                           document's kind and the duplicate to keep (S11)
  *
  * Every GET of /api/initiatives answers 202 { ok: false, pending: true } until the repository's first derivation lands (2C,
  * about 260 ms a record); a read waits and asks again, so a caller sees the answer or a real error, never the 202.
@@ -75,7 +78,10 @@ export async function rescan(ws, opts) {
 
 /** The duplicates a tidy offers (S10), and the tidy itself: `keep` is [{ id, role, keep }] for each group to tidy. */
 export const duplicates = (ws) => pmPost('/api/initiatives/duplicates', { ws });
-export const tidy = (ws, keep) => pmPost('/api/initiatives/tidy', { ws, keep });
+export const tidy = (ws, keep, kinds) => pmPost('/api/initiatives/tidy', kinds && kinds.length ? { ws, keep, kinds } : { ws, keep });
+/** Jev's check (S11). With no `plan` it answers the gates and the plan and sends nothing; with the plan the PM confirmed it asks Jev. */
+export const jevCheck = (ws, plan) => pmPost('/api/initiatives/jev-check', plan
+  ? { ws, confirm: true, expect_requests: plan.requests, expect_fingerprint: plan.fingerprint } : { ws });
 
 export const createInitiative = (ws, fields) => pmPost('/api/initiatives', { ws, ...fields });
 

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

@@ -22,6 +22,8 @@ export const GLOSSARY = {
   guide: 'initiatives-screen.md',
 };
 
+const KIND = { brief: 'problem brief', draft: 'PRD', review: 'evaluation', handoff: 'handoff', none: 'none of these' };
+
 export const COPY = {
   title: 'Initiatives',
   views: 'Initiatives view',
@@ -56,6 +58,23 @@ export const COPY = {
   tidyNone: 'Nothing to archive: every group is off.',
   tidyArchived: (n) => `Archived ${n} duplicate ${n === 1 ? 'document' : 'documents'}.`,
   tidyFailed: (why) => `Could not tidy: ${why}`,
+  // Jev checks each document's kind and picks the duplicate to keep, before the tidy (scan-documents S11)
+  jevTitle: 'Check documents with Jev',
+  jevPlan: (p) => `Jev reads ${p.documents} ${p.documents === 1 ? 'document' : 'documents'} tied to initiatives and says what kind each one is: problem brief, PRD, evaluation, handoff or none of these. Then it picks the version to keep where an initiative has more than one of a kind. This sends ${p.requests} ${p.requests === 1 ? 'request' : 'requests'} to ${p.host}${p.cached ? `; ${p.cached} ${p.cached === 1 ? 'document was' : 'documents were'} checked before and ${p.cached === 1 ? 'is' : 'are'} not sent again` : ''}. Only each document's title, headings and opening are sent, never its path or the whole file.`,
+  jevWithheld: (n) => `${n} ${n === 1 ? 'document is' : 'documents are'} not sent: ${n === 1 ? 'it is' : 'they are'} in an excluded folder or may contain a secret.`,
+  jevGo: (n) => (n ? `Check with Jev (${n} ${n === 1 ? 'request' : 'requests'})` : 'Check with Jev'),
+  jevSkip: 'Scan without Jev',
+  jevReading: 'Jev is reading the documents…',
+  jevFailed: (why) => `Jev could not check the documents: ${why}`,
+  jevShut: (why) => `Jev did not check the documents: ${why}`,
+  jevPaused: (why) => `${why} The scan uses the answers it has.`,
+  jevClean: (n) => `Jev checked ${n} ${n === 1 ? 'document' : 'documents'}: each kind is right and there are no duplicates.`,
+  jevKindsHead: (n) => `Jev reads ${n} ${n === 1 ? 'document' : 'documents'} as a different kind`,
+  jevKindsBody: 'A changed kind is written to the kinds file in the repository. The scan uses it from now on.',
+  jevKindLine: (c) => `${c.title} · ${c.path}: ${KIND[c.was] || c.was} → ${KIND[c.kind] || c.kind}`,
+  jevKindToggle: 'Use this kind',
+  jevConfirm: (k, n) => [k ? `Change ${k} ${k === 1 ? 'kind' : 'kinds'}` : '', n ? `archive ${n}` : ''].filter(Boolean).join(', ') + ' and scan',
+  jevRecorded: (n) => `Changed the kind of ${n} ${n === 1 ? 'document' : 'documents'}.`,
   rescanDone: (t) => `Read again at ${t}`,
   rescanFailed: (why) => `Could not re-scan: ${why}`,
   rescanSlow: 'The re-scan is still running. The view updates when it ends.',

package/workspace/public/pm/initiatives-ui.js

@@ -7,15 +7,18 @@
  *   checkBySheet({…})               a sheet with a date and Save or Clear
  *   say(out, ok)                    a toast for the answer of a write: the success text, or the server's refusal
  *   rescanRepo(ws)                  read the repository again now, with a toast at the start and at the end (scan-consistency R6);
- *                                   the tidy sheet first when a document repository has duplicates (scan-documents S10)
- *   tidySheet(duplicates)           the groups of duplicate documents, the one to keep in each, and Cancel, Skip or Archive
+ *                                   in a document repository, Jev's check first when its gates are open (scan-documents S11),
+ *                                   then the tidy sheet when there are kinds to change or duplicates (S10)
+ *   jevPlanSheet(plan)              what Jev would read and how many requests it sends, and Cancel, Scan without Jev or Check
+ *   tidySheet(duplicates)           the kinds Jev would change, the groups of duplicate documents, the one to keep in each,
+ *                                   and Cancel, Skip or Archive
  * No native dialog is used anywhere here. Every control is a primitive (primitives.js).
  */
 
 import { el } from './dom.js';
 import { button, field, signal, sheet, tabs, toast } from './primitives.js';
 import { COPY } from './initiatives-copy.js';
-import { rescan, duplicates, tidy } from './initiatives-api.js';
+import { rescan, duplicates, tidy, jevCheck } from './initiatives-api.js';
 
 export const horizonLabel = (h) => COPY.horizons[h] || h;
 export const progressText = (row) => (row && row.progress && row.progress.label) || '';
@@ -52,22 +55,25 @@ export function scanMoves(before, after) {
 
 /**
  * The tidy sheet (scan-documents S10): each group of documents that share an initiative and a role, with the one to keep
- * chosen, a switch to leave the group as it is, and three answers. Resolves { keep: [{ id, role, keep }] } on the confirm,
- * 'skip' on Scan without tidying, and null on Cancel, Escape or the backdrop.
+ * chosen, a switch to leave the group as it is, and three answers. Resolves { keep: [{ id, role, keep }], kinds } on the
+ * confirm, 'skip' on Scan without tidying, and null on Cancel, Escape or the backdrop. After Jev's check (S11) it also lists
+ * the kinds Jev would change, each with a switch, and each group says which version Jev picks; `kinds` is the switched-on ones.
  */
 export function tidySheet(d) {
   return new Promise((resolve) => {
     let settled = false;
     const finish = (v) => { if (settled) return; settled = true; resolve(v); };
     const state = d.groups.map((g) => ({ g, on: true, keep: g.keep }));
+    const fixes = (d.corrections || []).map((c) => ({ c, on: true }));
     const count = () => state.reduce((n, x) => n + (x.on ? x.g.files.length - 1 : 0), 0);
+    const label = () => (fixes.length ? COPY.jevConfirm(fixes.filter((x) => x.on).length, count()) : COPY.tidyConfirm(count()));
     const day = (t) => (t ? new Date(t * 1000).toISOString().slice(0, 10) : '');
     const err = el('p', { class: 'in-error', role: 'alert', 'data-in-error': '' });
     err.hidden = true;
     const groups = state.map((x, gi) => {
       const box = el('fieldset', { class: 'in-tidy__group', 'data-in-tidy-group': x.g.id + ':' + x.g.role });
       const toggle = el('input', { type: 'checkbox', checked: true, 'aria-label': COPY.tidyGroupToggle, 'data-in-tidy-on': '' });
-      toggle.addEventListener('change', () => { x.on = toggle.checked; if (x.on) box.removeAttribute('data-off'); else box.setAttribute('data-off', ''); go.textContent = COPY.tidyConfirm(count()); });
+      toggle.addEventListener('change', () => { x.on = toggle.checked; if (x.on) box.removeAttribute('data-off'); else box.setAttribute('data-off', ''); go.textContent = label(); });
       const head = el('legend', { class: 'in-tidy__head' }, toggle, `${x.g.title} · ${COPY.tidyRole[x.g.role] || x.g.role}`);
       const files = x.g.files.map((f) => {
         const radio = el('input', { type: 'radio', name: 'in-tidy-' + gi, value: f.path, checked: f.path === x.keep, 'data-in-tidy-keep': f.path });
@@ -76,21 +82,34 @@ export function tidySheet(d) {
         return el('label', { class: 'in-tidy__file' }, radio, el('span', null, el('span', { class: 'in-tidy__path' }, f.path), meta ? el('span', { class: 'in-note' }, ' · ' + meta) : null));
       });
       const shared = (x.g.shared || []).map((p) => el('p', { class: 'in-note in-tidy__file' }, COPY.tidyShared(p)));
-      box.replaceChildren(head, ...files, ...shared);
+      const jev = x.g.jev && x.g.jev.words ? [el('p', { class: 'in-note in-tidy__file', 'data-in-tidy-jev': '' }, x.g.jev.words)] : [];
+      box.replaceChildren(head, ...jev, ...files, ...shared);
       return box;
     });
+    const kindsBox = fixes.length ? (() => {
+      const box = el('fieldset', { class: 'in-tidy__group', 'data-in-tidy-kinds': '' });
+      const rows = fixes.map((x) => {
+        const t = el('input', { type: 'checkbox', checked: true, 'aria-label': COPY.jevKindToggle, 'data-in-tidy-kind': x.c.path });
+        t.addEventListener('change', () => { x.on = t.checked; go.textContent = label(); });
+        return el('label', { class: 'in-tidy__file' }, t, el('span', null, el('span', { class: 'in-tidy__path' }, COPY.jevKindLine(x.c)), x.c.words ? el('span', { class: 'in-note' }, ' · ' + x.c.words) : null));
+      });
+      box.replaceChildren(el('legend', { class: 'in-tidy__head' }, COPY.jevKindsHead(fixes.length)), el('p', { class: 'in-note in-tidy__file' }, COPY.jevKindsBody), ...rows);
+      return box;
+    })() : null;
     const inits = new Set(d.groups.map((g) => g.id)).size;
     const go = button({
-      label: COPY.tidyConfirm(count()), variant: 'primary', attrs: { 'data-in-tidy-confirm': '' },
+      label: label(), variant: 'primary', attrs: { 'data-in-tidy-confirm': '' },
       onClick: () => {
         const keep = state.filter((x) => x.on).map((x) => ({ id: x.g.id, role: x.g.role, keep: x.keep }));
-        if (!keep.length) { err.textContent = COPY.tidyNone; err.hidden = false; return; }
-        finish({ keep }); s.close();
+        const kinds = fixes.filter((x) => x.on).map((x) => ({ path: x.c.path, kind: x.c.kind, was: x.c.was, p: x.c.p }));
+        if (!keep.length && !kinds.length) { err.textContent = COPY.tidyNone; err.hidden = false; return; }
+        finish(kinds.length ? { keep, kinds } : { keep }); s.close();
       },
     });
     const s = sheet({
-      mode: 'auto', title: COPY.tidyTitle,
-      body: [el('p', { class: 'in-note' }, COPY.tidyBody(d.groups.length, inits, d.archive)), el('div', { class: 'in-tidy' }, groups), err],
+      mode: 'auto', title: fixes.length ? COPY.jevTitle : COPY.tidyTitle,
+      body: [d.groups.length ? el('p', { class: 'in-note' }, COPY.tidyBody(d.groups.length, inits, d.archive)) : null,
+        el('div', { class: 'in-tidy' }, ...(kindsBox ? [kindsBox] : []), ...groups), err].filter(Boolean),
       attrs: { 'data-in-sheet': 'tidy' },
       onClose: () => finish(null),
       actions: [
@@ -102,25 +121,73 @@ export function tidySheet(d) {
   });
 }
 
-/** Re-scan: read the repository again now. In a document repository with duplicates, the tidy sheet comes first (S10).
- *  A toast says the scan started and another says how it ended. Answers the rescan answer; the caller reloads what it
- *  shows when `ok`. */
+/**
+ * Jev's plan (scan-documents S11): how many documents Jev would read and how many requests that sends, before anything
+ * is sent. Resolves 'jev' on the check, 'skip' on Scan without Jev, and null on Cancel, Escape or the backdrop.
+ */
+export function jevPlanSheet(plan) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (v) => { if (settled) return; settled = true; resolve(v); };
+    const s = sheet({
+      mode: 'auto', title: COPY.jevTitle,
+      body: [el('p', { class: 'in-note' }, COPY.jevPlan(plan)), plan.withheld_count || plan.excluded ? el('p', { class: 'in-note' }, COPY.jevWithheld((plan.withheld_count || 0) + (plan.excluded || 0))) : null].filter(Boolean),
+      attrs: { 'data-in-sheet': 'jev-plan' },
+      onClose: () => finish(null),
+      actions: [
+        button({ label: COPY.cancel, variant: 'outline', onClick: () => s.close(), attrs: { 'data-in-cancel': '' } }),
+        button({ label: COPY.jevSkip, variant: 'outline', onClick: () => { finish('skip'); s.close(); }, attrs: { 'data-in-jev-skip': '' } }),
+        button({ label: COPY.jevGo(plan.requests), variant: 'primary', onClick: () => { finish('jev'); s.close(); }, attrs: { 'data-in-jev-go': '' } }),
+      ],
+    });
+  });
+}
+
+/** Jev's part of a scan (S11): the plan, the PM's confirm, then the check. Answers { cancelled } on Cancel, { review } with
+ *  the kinds to change and the groups when Jev answered, or { note } with what to say when Jev did not check. */
+async function jevStep(ws) {
+  const j = await jevCheck(ws);
+  if (!j || !j.ok || j.profile !== 'pm-artifacts') return {};
+  if (!j.gates || !j.gates.open) return { note: COPY.jevShut(j.gates && j.gates.sentence ? j.gates.sentence : 'it is switched off.') };
+  if (!j.plan || !j.plan.documents) return {};
+  const go = await jevPlanSheet(j.plan);
+  if (!go) return { cancelled: true };
+  if (go === 'skip') return {};
+  toast({ text: COPY.jevReading, timeout: 6000 });
+  const r = await jevCheck(ws, j.plan);
+  if (!r || !r.ok) return { failed: COPY.jevFailed((r && r.error) || 'no answer') };
+  const pre = r.paused ? COPY.jevPaused(r.paused) + ' ' : '';
+  if (!(r.corrections || []).length && !(r.groups || []).length) return { note: pre + COPY.jevClean(r.checked || 0) };
+  return { review: { corrections: r.corrections || [], groups: r.groups || [], archive: r.archive }, note: pre || null };
+}
+
+/** Re-scan: read the repository again now. In a document repository, Jev's check comes first when its gates are open
+ *  (S11), then the tidy sheet: the kinds Jev would change and the duplicates by Jev's kinds and picks. With Jev's gates
+ *  shut, or on Scan without Jev, the tidy sheet lists the duplicates the file names show (S10). A toast says the scan
+ *  started and another says how it ended. Answers the rescan answer; the caller reloads what it shows when `ok`. */
 export async function rescanRepo(ws) {
   let first = null;
-  const d = await duplicates(ws);
-  if (d && d.ok && Array.isArray(d.groups) && d.groups.length) {
+  const jv = await jevStep(ws);
+  if (jv.cancelled) return { ok: false, cancelled: true };
+  if (jv.failed) toast({ text: jv.failed, tone: 'error', timeout: 8000 });
+  let d = jv.review || null;
+  if (!d) { const dup = await duplicates(ws); if (dup && dup.ok && Array.isArray(dup.groups) && dup.groups.length) d = dup; }
+  if (d) {
     const pick = await tidySheet(d);
     if (!pick) return { ok: false, cancelled: true };
-    if (pick !== 'skip') first = () => tidy(ws, pick.keep);
+    if (pick !== 'skip') first = () => tidy(ws, pick.keep, pick.kinds);
   }
   toast({ text: COPY.rescanning, timeout: 4000 });
   const a = await rescan(ws, first ? { first } : null);
   const t = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
   const moved = a && a.ok && a.after ? scanMoves(a.before, a.after) : null;
-  const archived = a && a.tidied && Array.isArray(a.tidied.moved) && a.tidied.moved.length ? COPY.tidyArchived(a.tidied.moved.length) + ' ' : '';
+  const td = a && a.tidied;
+  const archived = (td && td.kinds_written ? COPY.jevRecorded(td.kinds_written) + ' ' : '')
+    + (td && Array.isArray(td.moved) && td.moved.length ? COPY.tidyArchived(td.moved.length) + ' ' : '');
+  const note = jv.note ? ' ' + jv.note : '';
   if (!a || !a.ok) toast({ text: first && a && !a.after && !a.slow ? COPY.tidyFailed((a && a.error) || 'no answer') : COPY.rescanFailed((a && a.error) || 'no answer'), tone: 'error', timeout: 8000 });
-  else if (a.slow) toast({ text: archived + COPY.rescanSlow, timeout: 6000 });
-  else toast({ text: archived + (moved ? COPY.rescanResult(moved.checked, moved.moves, (a.after && a.after.scan) || null) : COPY.rescanDone(t)), timeout: 10000 });
+  else if (a.slow) toast({ text: archived + COPY.rescanSlow + note, timeout: 6000 });
+  else toast({ text: archived + (moved ? COPY.rescanResult(moved.checked, moved.moves, (a.after && a.after.scan) || null) : COPY.rescanDone(t)) + note, timeout: 10000 });
   try { if (a && a.ok) window.dispatchEvent(new CustomEvent('pmos:initiatives-changed')); } catch { /* no window */ }
   return a || { ok: false };
 }

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

@@ -11,7 +11,7 @@
  *   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()
+ *   minimize() · activeId() · forget(id)
  */
 import { el } from './dom.js';
 import { button, iconButton, layer, toast, ensureComponentsCss } from './primitives.js';
@@ -74,6 +74,13 @@ export async function openDock(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();
@@ -127,11 +134,10 @@ function draw() {
       live ? null : iconButton({ icon: 'x', ariaLabel: 'Put the note away', onClick: close, attrs: { 'data-nt-dock-close': '' } })));
     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 },
-    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);
+  const pop = el('section', { class: 'nt-pop', role: 'dialog', 'aria-label': 'Meeting note', 'data-nt-pop': active.id }, body);
   host.replaceChildren(pop);
-  if (!v.renderInline(body, viewCtx, active.id)) body.appendChild(el('p', { class: 'nt-hint' }, 'Another note is being taken.'));
+  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': '' } }));
 }