create-pmos 0.241.0 → 0.243.0

package/workspace/public/pm/c3-report-deck.css

@@ -156,3 +156,8 @@
   .c3 .rd-dks-chat { position: static; max-height: none; }
   .c3 .rd-dks-log { max-height: 420px; }
 }
+
+/* meeting-material-replay-gaps: the audience window shows the slides only, so the toolbar is hidden; a window with no deck says why in one line */
+body.c3-aud-win { margin: 0; }
+body.c3-aud-win .rd-ov .rp-deck__bar { display: none; }
+.c3.aud-msg { display: grid; place-items: center; min-height: 100vh; padding: var(--sp-3); text-align: center; }

package/workspace/public/pm/c3-report-deck.js

@@ -20,6 +20,7 @@ import { icon, pbtn, btn, chip, sect, put, lk } from './c3-ini-ui.js';
 import { pmGet, pmPost } from './http.js';
 import { toast } from './c3-toast.js';
 import { ensureC3Css } from './pm-work-view.js';
+import { openAudienceWindow } from './c3-audience-link.js';
 
 export const W = 1280;
 export const H = 720;
@@ -266,7 +267,7 @@ export function createDeck(o) {
           btn({ 'data-rd-act': 'mode', 'data-v': 'cmp', 'aria-pressed': String(S.mode === 'cmp'), onclick: () => { S.mode = 'cmp'; paint(); } }, 'Side by side with ' + prevWord())) : null),
       el('div', { class: 'chips2 rd-wrap' },
         isDeck() ? pbtn('primary', 'Present', 'play', { 'data-rd-act': 'present', onclick: () => present('pres') }) : null,
-        isDeck() ? pbtn('outline', 'Audience view', 'eye', { 'data-rd-act': 'audience', onclick: () => present('aud') }) : null,
+        isDeck() ? pbtn('outline', 'Audience view', 'eye', { 'data-rd-act': 'audience', onclick: () => audienceView() }) : null,
         pbtn('outline', 'Refine the design', 'spark', { 'data-rd-act': 'studio', onclick: () => o.onStudio && o.onStudio() }),
         pbtn('ghost', 'Print / PDF', 'pdf', { 'data-rd-act': 'print', onclick: () => doPrint() }),
         isDeck() ? pbtn('ghost', 'Download .pptx', 'drop', { 'data-rd-act': 'pptx', onclick: () => S.api && S.api.download && S.api.download('pptx') }) : null));
@@ -483,9 +484,36 @@ export function createDeck(o) {
 
   /* ── Present: the presenter view and the audience view, on the .rp-deck stage ── */
   let OV = null;
+  /* The audience window (initiative meeting-material-replay-gaps): a page of its own that shows the slides only and follows this view's slide. */
+  let AUD = null;
+  function closeAud() {
+    if (!AUD) return;
+    try { if (AUD.ch) { AUD.ch.postMessage({ t: 'close' }); AUD.ch.close(); } } catch { /* gone */ }
+    try { if (AUD.win && !AUD.win.closed) AUD.win.close(); } catch { /* gone */ }
+    AUD = null;
+  }
+  /** Open the audience window. → true, or false when the browser blocked it (the caller falls back to the full-screen view in this window). */
+  function openAudience() {
+    if (!isDeck()) return false;
+    if (AUD && AUD.win && !AUD.win.closed) { try { AUD.win.focus(); } catch { /* blocked */ } return true; }
+    const w = openAudienceWindow({ ws, path, name: (o.name || 'Report') + (o.cycle ? ' · ' + o.cycle : ''), start: OV ? OV.i : S.cur });
+    if (!w) return false;
+    AUD = w;
+    if (AUD.ch) AUD.ch.onmessage = (e) => {
+      const m = e && e.data; if (!m || typeof m !== 'object') return;
+      if (m.t === 'hello') AUD.ch.postMessage({ t: 'slide', i: OV ? OV.i : S.cur });
+      else if (m.t === 'slide' && Number.isInteger(m.i)) { if (OV) ovGo(m.i, { quiet: true }); else { S.cur = Math.max(0, Math.min(count() - 1, m.i)); } }
+    };
+    return true;
+  }
+  /** The Audience view press: the window, else (blocked) the full-screen view in this window with a notice that says why. */
+  function audienceView() {
+    if (openAudience()) return;
+    toast({ text: 'The audience window was blocked. Allow pop-ups for this page, or use the full-screen view here.', actionLabel: 'Full-screen view here', timeout: 10000, onAction: () => present('aud') });
+  }
   function closeOV() {
     if (!OV) return; clearInterval(OV.timer); window.removeEventListener('keydown', OV.key, true); window.removeEventListener('resize', OV.fit);
-    OV.host.remove(); const i = OV.i; OV = null; S.cur = i; paint(); const b = root.querySelector('[data-rd-act="present"]'); if (b) b.focus();
+    OV.host.remove(); const i = OV.i; OV = null; S.cur = i; closeAud(); if (o.standalone) { try { window.close(); } catch { /* not ours to close */ } return; } paint(); const b = root.querySelector('[data-rd-act="present"]'); if (b) b.focus();
   }
   function present(kind, start) {
     if (!isDeck()) return;
@@ -513,7 +541,13 @@ export function createDeck(o) {
     else if (k === 'Home') { e.preventDefault(); e.stopImmediatePropagation(); ovGo(0); }
     else if (k === 'End') { e.preventDefault(); e.stopImmediatePropagation(); ovGo(count() - 1); }
   }
-  function ovGo(j) { if (!OV) return; const n = Math.max(0, Math.min(count() - 1, j)); if (n === OV.i) return; OV.i = n; paintOV(); }
+  function ovGo(j, opt) {
+    if (!OV) return; const n = Math.max(0, Math.min(count() - 1, j)); if (n === OV.i) return; OV.i = n; paintOV();
+    if (!(opt && opt.quiet)) {
+      if (AUD && AUD.ch) { try { AUD.ch.postMessage({ t: 'slide', i: n }); } catch { /* closed */ } }
+      if (typeof o.onSlide === 'function') o.onSlide(n);
+    }
+  }
   const clock = () => { const s = Math.floor((Date.now() - OV.t0) / 1000); return pad2(Math.floor(s / 60)) + ':' + pad2(s % 60); };
   function fitOV() {
     if (!OV) return;
@@ -525,7 +559,7 @@ export function createDeck(o) {
       btn({ class: 'ib', 'aria-label': 'Previous slide', 'data-rd-ovact': 'prev', disabled: OV.i === 0, onclick: () => ovGo(OV.i - 1) }, icon('prev')),
       el('p', { class: 'rp-deck__count', 'data-rd-count': '' }, (OV.i + 1) + ' / ' + N),
       btn({ class: 'ib', 'aria-label': 'Next slide', 'data-rd-ovact': 'next', disabled: OV.i === N - 1, onclick: () => ovGo(OV.i + 1) }, icon('next')),
-      OV.kind === 'pres' ? pbtn('ghost', 'Audience view', 'eye', { 'data-rd-ovact': 'aud', onclick: () => { OV.kind = 'aud'; paintOV(); } }) : pbtn('ghost', 'Presenter view', 'mic', { 'data-rd-ovact': 'pres', onclick: () => { OV.kind = 'pres'; paintOV(); } }),
+      OV.kind === 'pres' ? pbtn('ghost', 'Audience view', 'eye', { 'data-rd-ovact': 'aud', onclick: () => audienceView() }) : pbtn('ghost', 'Presenter view', 'mic', { 'data-rd-ovact': 'pres', onclick: () => { OV.kind = 'pres'; paintOV(); } }),
       btn({ class: 'ib', 'aria-label': 'Close the slides (Escape)', 'data-rd-ovact': 'close', onclick: () => closeOV() }, icon('x')));
   }
   function paintOV() {
@@ -557,6 +591,8 @@ export function createDeck(o) {
     state: S,
     node(api) { S.api = api; if (!S.loaded || !S.cyc || !S.cyc.designed) return null; paint(); return root; },
     tools() { return S.loaded && S.cyc && S.cyc.designed && isDeck() ? [btn({ class: 'ib sm', 'aria-label': 'Present', title: 'Present', 'data-rd-act': 'present-top', onclick: () => present('pres') }, icon('play', 'sm'))] : []; },
-    present, reload: load, close: closeOV,
+    present, reload: load, close: closeOV, audience: audienceView, openAudience,
+    /** Move to slide j (the audience window follows the presenter this way). opt.quiet: do not tell the other window. */
+    goTo(j, opt) { if (OV) ovGo(j, opt); else S.cur = Math.max(0, Math.min(count() - 1, j)); },
   };
 }

package/workspace/public/pm/c3-report-setup.css

@@ -60,3 +60,8 @@
 
 .c3 .rs-min0 { min-width: 0; }
 .c3 .rs-kv .chip2 + .rs-help { margin-left: 6px; }
+
+/* report-structure-gaps: a report whose draft a session is making (Drafting…), waiting for a check, or whose session ended */
+.c3 .rs-dr { display: grid; gap: 4px; }
+.c3 .rs-dot { display: inline-block; width: 6px; height: 6px; margin-right: 6px; border-radius: 50%; background: currentColor; animation: pmblink 1.4s step-end infinite; }
+@media (prefers-reduced-motion: reduce) { .c3 .rs-dot { animation: none; } }

package/workspace/public/pm/c3-report-setup.js

@@ -224,16 +224,34 @@ export function mountReportSetup(host, ctx) {
     toast('Drafting ' + s.name + ' now. Nothing is sent.');
     draftNow(s).then((nd) => { if (nd) openReportDoc(nd); });
   }
+  /** The line under a report that is being drafted by a session (report-structure-gaps), or that lost its session. */
+  function draftChips(s, dr) {
+    const d = s.draft;
+    if (dr && dr.state === 'drafting') return el('div', { class: 'rs-dr', 'data-rs-drafting': '' },
+      el('div', { class: 'chips' }, el('span', { class: 'tag acc' }, el('span', { class: 'rs-dot', 'aria-hidden': 'true' }), 'Drafting…'), chip(icon('check', 'sm'), 'Following saved structure' + (dr.saved != null ? ' S' + dr.saved : '')), chip(icon('clock', 'sm'), 'Started ' + timeText(dr.since))),
+      el('div', { class: 'dim rs-help' }, 'Reading the sources and working out the charts. This takes a few minutes. You can leave this page.'));
+    if (dr && dr.state === 'held') return el('div', { class: 'rs-dr', 'data-rs-drafting': 'held' },
+      el('div', { class: 'chips' }, el('span', { class: 'tag warn' }, 'Waiting for a check'), (dr.sources || []).map((n) => chip(icon('shield', 'sm'), n + ' needs you')), chip(icon('clock', 'sm'), 'Drafts without it after 4 hours')),
+      el('div', { class: 'dim rs-help' }, 'The draft starts when the check passes, or after 4 hours without that source. Open Shape the report to check it again.'));
+    if (d && d.state === 'ended') return el('div', { class: 'rs-dr', 'data-rs-drafting': 'ended' },
+      el('div', { class: 'chips' }, el('span', { class: 'tag bad' }, 'Draft did not finish')), el('div', { class: 'dim rs-help' }, d.reason || 'The drafting session ended before a draft was written.'));
+    return null;
+  }
+  const timeText = (iso) => { const t = new Date(iso); return Number.isNaN(t.getTime()) ? '' : String(t.getHours()).padStart(2, '0') + ':' + String(t.getMinutes()).padStart(2, '0'); };
   function setupRow(s) {
     const paused = s.status === 'paused'; const cy = docsOf(RS.docs, s.id); const n = s.cycles != null ? s.cycles : cy.length; const open = RS.cyc.has(s.id);
-    return el('li', { class: 'nrow', 'data-rs-reg': s.id }, el('span', { class: 'ki' }, icon('report')),
+    const dr = s.draft && (s.draft.state === 'drafting' || s.draft.state === 'held') ? s.draft : null;
+    return el('li', { class: 'nrow', 'data-rs-reg': s.id, 'data-rs-draft': dr ? dr.state : (s.draft ? s.draft.state : '') }, el('span', { class: 'ki' }, icon('report')),
       el('div', { class: 'nb' }, btn({ class: 'tt', 'data-rs-act': 'open-reg', onclick: () => openSetup(s) }, s.name),
+        draftChips(s, dr),
         el('div', { class: 'chips' }, RS.newIds.has(s.id) ? el('span', { class: 'tag acc' }, 'New') : null, srcChip(s.source), outChip(s.output), copyChip(s.output, s.copy), paused ? el('span', { class: 'tag warn' }, 'Paused') : null,
           chip(icon('cal', 'sm'), s.label || scheduleLabel(s.schedule)), paused ? null : chip(icon('clock', 'sm'), 'Next draft ' + (s.next_draft ? dayText(s.next_draft) : 'not set yet')),
           chip(icon('mail', 'sm'), 'Last issued ' + (s.last_issued ? dayText(s.last_issued) : 'not yet'))),
         open ? cycRows(s) : null),
-      el('div', { class: 'acts' }, cy.length || paused || s.source !== 'work' ? pbtn('outline', 'Open', 'out', { 'data-rs-act': 'open-reg', onclick: () => openSetup(s) })
+      el('div', { class: 'acts' }, dr ? pbtn('outline', 'Drafting…', 'spark', { 'data-rs-act': 'draft-now', disabled: true, title: dr.state === 'held' ? 'The draft waits for a check of a source.' : 'A draft is being made. Wait for it to land.' })
+        : cy.length || paused || s.source !== 'work' ? pbtn('outline', 'Open', 'out', { 'data-rs-act': 'open-reg', onclick: () => openSetup(s) })
         : pbtn('outline', 'Draft it now', 'spark', { 'data-rs-act': 'draft-now', onclick: () => openSetup(s) }),
+        dr && dr.state === 'drafting' && dr.session ? pbtn('ghost', 'Watch the session', 'eye', { 'data-rs-act': 'watch-draft', onclick: () => import('./c3-session-term.js').then((m) => m.openSessionTerm({ id: dr.session, name: 'Draft ' + s.name })).catch(() => {}) }) : null,
         s.source === 'work' ? pbtn('ghost', 'Shape the report', 'todo', { 'data-rs-act': 'shape', onclick: () => openStructure({ ws: RS.ws, id: s.id, name: s.name }) }) : null,
         s.source === 'work' ? pbtn('ghost', 'Design how it looks', 'spark', { 'data-rs-act': 'design', onclick: () => openStudio({ ws: RS.ws, id: s.id, name: s.name }) }) : null,
         pbtn('ghost', 'All cycles (' + n + ')', 'fold', { 'data-rs-act': 'cyc', 'aria-expanded': String(open), onclick: () => { if (RS.cyc.has(s.id)) RS.cyc.delete(s.id); else RS.cyc.add(s.id); drawSetups(); } }),

package/workspace/public/pm/c3-report-store.js

@@ -69,13 +69,16 @@ export function normProposal(p) {
     fixes: Array.isArray(q.fixes) ? q.fixes : [], sections: Array.isArray(q.sections) ? q.sections : [], sources: Array.isArray(q.sources) ? q.sources : [], found: Array.isArray(q.found) ? q.found : [] };
 }
 
+/** The setups whose draft a session is making (report-structure-gaps): a draft that follows a saved structure, or one held for a check. */
+export const draftingSetups = () => (RS.setups || []).filter((x) => x.draft && (x.draft.state === 'drafting' || x.draft.state === 'held'));
+
 /* ── the state ── */
 export const RS = { ws: '', setups: [], findings: [], asks: [], finder: null, docs: [], loaded: false, err: '', hidden: new Set(), newIds: new Set(), askText: '', docF: { state: 'all', src: 'all' }, cyc: new Set(),
   edit: {}, chg: {}, openFinding: null, names: (k) => k };
 const subs = new Set(); let timer = null; let inflight = null;
 export const onReports = (fn) => { subs.add(fn); return () => { subs.delete(fn); if (!subs.size) stopPoll(); }; };
 const emit = () => { for (const f of [...subs]) { try { f(); } catch { /* one view's error is its own */ } } };
-const running = () => RS.asks.some((a) => a.state === 'running');
+const running = () => RS.asks.some((a) => a.state === 'running') || draftingSetups().length > 0;
 function stopPoll() { if (timer) { clearInterval(timer); timer = null; } }
 function poll() { if (!timer && running() && subs.size) timer = setInterval(() => { if (!running() || !subs.size) { stopPoll(); return; } loadReports(RS.ws, true); }, 2500); }
 
@@ -88,11 +91,24 @@ export function loadReports(ws, force) {
     inflight = null;
     if (a && a.ok !== false && Array.isArray(a.setups)) { RS.setups = a.setups; RS.findings = a.findings || []; RS.asks = a.asks || []; RS.finder = a.finder || RS.finder; RS.err = ''; } else RS.err = (a && (a.error || a.reason)) || 'The report set-ups could not be read.';
     if (b && b.ok !== false && Array.isArray(b.docs)) RS.docs = b.docs; else if (!RS.err) RS.err = (b && (b.error || b.reason)) || 'The report documents could not be read.';
-    RS.loaded = true; emit(); poll(); return RS;
+    RS.loaded = true; landedDrafts(); emit(); poll(); return RS;
   });
   inflight = run; return run;
 }
 
+/** A draft a session was making is no longer drafting: say it is ready (with Open), or why it ended. Remembers the names between reads. */
+const wasDrafting = new Map();
+function landedDrafts() {
+  const now = new Map(draftingSetups().map((x) => [x.id, x.name]));
+  for (const [id, name] of wasDrafting) {
+    if (now.has(id)) continue;
+    const st = (RS.setups || []).find((x) => x.id === id);
+    if (st && st.draft && st.draft.state === 'ended') toast({ text: 'The draft of ' + name + ' did not finish. ' + (st.draft.reason || ''), tone: 'error', timeout: 8000 });
+    else openDraftToast(id, 'Draft ready. ' + name + '. Nothing is sent.');
+  }
+  wasDrafting.clear(); for (const [id, name] of now) wasDrafting.set(id, name);
+}
+
 /* ── the presses ── */
 const post = (path, body) => Promise.resolve(pmPost('/api/report-setups/' + path, { ws: RS.ws, ...body })).catch((e) => ({ ok: false, error: String((e && e.message) || e) }));
 const fail = (r, what) => toast({ text: what + ': ' + ((r && (r.error || r.reason)) || 'the workspace did not answer') + '.', tone: 'error', timeout: 6000 });
@@ -127,6 +143,12 @@ function openDraftToast(id, text) {
 /** Draft it now: the next cycle of a set-up report. → the new draft document, or null. */
 export async function draftNow(setup) {
   const r = await post('draft', { id: setup.id }); if (!r || !r.ok) { fail(r, 'It was not drafted'); return null; }
+  // A report with a saved structure is drafted by a session: the answer is "started". The row shows Drafting… and the poll announces the file.
+  if (r.drafting) {
+    toast(r.held ? 'The draft of ' + setup.name + ' waits for a check of a source. It starts when the check passes.' : 'Drafting ' + setup.name + ' now. It follows the saved structure. Nothing is sent.');
+    await loadReports(RS.ws, true);
+    return null;
+  }
   await loadReports(RS.ws, true);
   return (RS.docs || []).find((x) => x.setup === setup.id && x.slot === r.drafted.slot) || null;
 }

package/workspace/public/pm/c3-report-structure.css

@@ -38,3 +38,7 @@
   .c3 .rs-st .rd-dks-chat { position: static; max-height: none; }
   .c3 .rs-st .rd-dks-log { max-height: 420px; }
 }
+
+/* report-structure-gaps: a source row while Test pull reads it (the same dot as a report row that is being drafted) */
+.c3 .rs-dot { display: inline-block; width: 6px; height: 6px; margin-right: 6px; border-radius: 50%; background: currentColor; animation: pmblink 1.4s step-end infinite; }
+@media (prefers-reduced-motion: reduce) { .c3 .rs-dot { animation: none; } }

package/workspace/public/pm/c3-report-structure.js

@@ -34,6 +34,7 @@ export const RSX = {
   remove: (b) => post('report-structure/remove', b),
   check: (b) => post('report-structure/check', b),
   runDry: (b) => post('report-structure/dry', b),
+  pull: (b) => post('report-structure/pull', b),
 };
 const failed = (r, what) => toast({ text: what + ': ' + ((r && (r.error || r.reason)) || 'the workspace did not answer') + '.', tone: 'error', timeout: 6000 });
 
@@ -89,6 +90,10 @@ export function openStructure({ ws, id, name, view, onClose } = {}) {
   const running = () => !!(S.D && S.D.running);
   const dryRunning = () => running() && /dry/.test(JSON.stringify(S.D.job || ''));
   const checksRunning = () => Object.values((S.D && S.D.checks) || {}).some((c) => c && c.running);
+  const pulling = (sid) => !!(S.D && Array.isArray(S.D.pulling) && S.D.pulling.includes(sid));
+  const pullsRunning = () => !!(S.D && Array.isArray(S.D.pulling) && S.D.pulling.length);
+  const pullOf = (sid) => (S.D && S.D.pulls && S.D.pulls[sid]) || null;
+  const localHm = (iso) => { const t = new Date(iso); return Number.isNaN(t.getTime()) ? '' : String(t.getHours()).padStart(2, '0') + ':' + String(t.getMinutes()).padStart(2, '0'); };
   const scrollLog = () => requestAnimationFrame(() => { const l = body.querySelector('.rd-dks-log'); if (l) l.scrollTop = l.scrollHeight; });
 
   /* follow: show the current version when it changed (a job landed). A read that changed nothing paints nothing: the poll reads the structure
@@ -100,7 +105,7 @@ export function openStructure({ ws, id, name, view, onClose } = {}) {
     const prev = S.D ? S.D.current : null;
     S.D = r.structure; S.setup = r.setup || { id, name };
     if (K.ver == null || (S.D.current != null && !ver(K.ver)) || (follow && S.D.current !== prev && S.D.current != null)) K.ver = S.D.current;
-    if (running() || checksRunning()) poll(); else clearTimeout(S.timer);
+    if (running() || checksRunning() || pullsRunning()) poll(); else clearTimeout(S.timer);
     await Promise.all([need(K.ver), need(K.ver > 1 ? K.ver - 1 : null), readDry(), readCharts()]);
     paint(false);
   }
@@ -255,9 +260,10 @@ export function openStructure({ ws, id, name, view, onClose } = {}) {
     S.dry = null; await load(true);
   }
   async function testPull(s) {
-    const r = await RSX.turn({ ws, id, text: 'Test pull from ' + s.name + ': read it now for the last complete period and tell me which charts that use it returned a number.' });
-    if (!r || !r.ok) { if (r && r.status === 409) toast('A version is being made. Wait for it to land.'); else failed(r, 'The test pull did not start'); return; }
-    toast('PMOS is reading ' + s.name + '. The answer shows in the conversation.'); await load(true); scrollLog();
+    // Test pull reads the one source into its row. It is not a turn: no line in the conversation, no new version (report-structure-gaps).
+    const r = await RSX.pull({ ws, id, source: s.id });
+    if (!r || !r.ok) { failed(r, 'The test pull did not start'); return; }
+    toast('PMOS is reading ' + s.name + '. The answer shows in its row.'); await load(true);
   }
   function openIt(s) {
     closeSheet();
@@ -273,15 +279,23 @@ export function openStructure({ ws, id, name, view, onClose } = {}) {
     const uses = (p.charts || []).filter((c) => c.source === s.id).length; const pm = s.group === 'pmos';
     const [tone, word] = STATE_TAG[s.state] || ['', s.state];
     const eye = s.kind === 'chrome' || s.kind === 'computer';
+    const pl = !pm && !eye ? pullOf(s.id) : null; const plNow = pl && pl.n === K.ver ? pl : null; const busyPull = pulling(s.id);
     const act = pm ? pbtn('ghost', 'Open', 'out', { 'data-st-act': 'openpm', 'data-v': s.id, onclick: () => openIt(s) })
       : eye ? pbtn('ghost', 'Check it works', 'shield', { 'data-st-act': 'chkopen', 'data-v': s.id, onclick: () => check(s.id) })
-        : s.state === 'reached' ? pbtn('ghost', 'Test pull', 'play', { 'data-st-act': 'test', 'data-v': s.id, onclick: () => testPull(s) })
+        : s.state === 'reached' ? pbtn('ghost', busyPull ? 'Reading…' : pl ? 'Test pull again' : 'Test pull', 'play', { 'data-st-act': 'test', 'data-v': s.id, disabled: busyPull, onclick: () => testPull(s) })
           : pbtn('ghost', 'How to connect', 'info', { 'data-st-act': 'connect', 'data-v': s.id, onclick: () => toast('Connect ' + s.name + ' in your Claude connectors (Settings, Connectors), then come back and press Test pull. PMOS reads it read only.') });
     const li = el('li', { class: 'nrow', 'data-st-src': s.id }, el('span', { class: 'ki' }, icon(KIND_IC[s.kind] || 'doc')),
       el('div', { class: 'nb' }, el('span', { class: 'tt' }, s.name),
         el('div', { class: 'chips' }, el('span', { class: 'tag' + (tone ? ' ' + tone : ''), 'data-st-state': s.state }, word), s.via ? chip(icon(s.state === 'reached' ? 'lock' : 'info', 'sm'), s.via) : null,
+          busyPull ? el('span', { class: 'tag acc', 'data-st-pulling': '' }, el('span', { class: 'rs-dot', 'aria-hidden': 'true' }), 'Reading…') : null,
+          plNow && !busyPull ? el('span', { class: 'tag ' + (plNow.ok ? 'ok' : 'bad'), 'data-st-pulled': plNow.ok ? 'ok' : 'none' }, icon(plNow.ok ? 'check' : 'alert', 'sm'), plNow.ok ? 'Pulled ' + localHm(plNow.at) : 'Returned nothing') : null,
+          plNow && !busyPull && plNow.ok ? chip(icon('cal', 'sm'), plNow.period) : null, plNow && !busyPull && !plNow.ok ? chip(icon('clock', 'sm'), 'Tried ' + localHm(plNow.at)) : null,
+          plNow && !busyPull && plNow.ok ? chip(icon('report', 'sm'), plNow.got + ' of ' + plNow.charts + (plNow.charts === 1 ? ' chart returned a number' : ' charts returned a number')) : null,
           uses ? chip(icon('report', 'sm'), uses + (uses === 1 ? ' chart' : ' charts')) : null, eye ? chip(icon('clock', 'sm'), 'Re-checked 1 hour before each draft') : null),
-        s.use ? el('div', { class: 'dim rs-st-small' }, s.use) : null),
+        busyPull ? el('div', { class: 'dim rs-st-small', 'data-st-pullnote': '' }, 'Reading the last complete period for the ' + (uses === 1 ? 'chart' : uses + ' charts') + ' that use it. Read only.')
+          : plNow && !plNow.ok ? el('div', { class: 'dim rs-st-small', 'data-st-pullnote': '' }, plNow.reason || 'The source returned nothing.')
+            : !pm && !eye && s.state === 'reached' && !plNow ? el('div', { class: 'dim rs-st-small', 'data-st-pullnote': '' }, 'Not tried on this version.')
+              : s.use ? el('div', { class: 'dim rs-st-small' }, s.use) : null),
       el('div', { class: 'acts' }, act, pbtn('ghost', 'Remove', 'trash', { 'data-st-act': 'dropsrc', 'data-v': s.id, onclick: () => drop('source', s.id, s.name) })));
     return li;
   }
@@ -298,8 +312,12 @@ export function openStructure({ ws, id, name, view, onClose } = {}) {
   }
   function chartDetail(c, p) {
     const dv = S.dry && S.dry.n === K.ver ? (S.dry.values || []).find((v) => v.chart === c.id) : null;
-    const tp = dv ? [el('b', null, dv.value), ' ', el('span', { class: 'dim' }, dv.was || ''), ' ', dv.delta ? el('span', { class: 'chip2 mono' }, dv.delta) : null, ' ', dv.flag ? el('span', { class: 'tag warn' }, 'Flagged') : null]
-      : ['Not tried on this version. Press Try it with real data.'];
+    const sp = pullOf(c.source); const pv = sp && sp.n === K.ver ? (sp.values || []).find((v) => v.chart === c.id) : null;
+    const srcName = ((planShown() || {}).sources || []).find((x) => x.id === c.source);
+    const val = (v) => [el('b', null, v.value), ' ', el('span', { class: 'dim' }, v.was ? 'was ' + v.was : ''), ' ', v.delta ? el('span', { class: 'chip2 mono' }, v.delta) : null, ' ', v.flag ? el('span', { class: 'tag warn' }, 'Flagged') : null];
+    const tp = pv ? [...val(pv), el('br'), el('span', { class: 'dim rs-st-small', 'data-st-pulled-from': '' }, 'Pulled from ' + (srcName ? srcName.name : 'the source') + ' at ' + localHm(sp.at) + ', ' + sp.period + '. Not saved in the report.')]
+      : dv ? val(dv)
+        : ['Not tried on this version. Press Test pull on its source, or Try it with real data.'];
     const f = (lab, ...c2) => el('div', null, el('span', { class: 'dim mono' }, lab), ...c2);
     return el('tr', { class: 'rs-st-det', 'data-st-detail': c.id }, el('td', { colspan: '5' }, el('div', { class: 'rs-st-detb' },
       f('QUESTION IT ANSWERS', el('p', { 'data-st-q': '' }, c.question || '')), f('USED IN', el('p', { 'data-st-used': '' }, usersOf(c))),

package/workspace/public/pm/c3-shell.js

@@ -612,6 +612,8 @@ async function boot() {
   /* ?studio=<report id> opens that report's design studio over the Reports tab (the PMOS Chrome extension's Open the studio). */
   if (q.get('studio') && /^[a-z][a-z0-9-]{0,39}$/.test(q.get('studio'))) { if (!start) start = 'rep'; import('./c3-design-studio.js').then((m) => m.openStudio({ ws: S.ws, id: q.get('studio'), name: '' })).catch(() => { /* the studio is not available */ }); }
   /* ?structure=<report id> opens that report's Structure step (the studio's step 1) over the Reports tab. */
+  // ?replay=<note id> opens the meeting replay of that note (initiative meeting-material-replay-gaps). An id that is not a note id opens the replay page's own error, and makes no request.
+  if (q.get('replay')) import('./c3-replay.js').then((m) => m.openReplay(m.NOTE_ID_RE.test(q.get('replay')) ? { note: q.get('replay') } : { note: '' })).catch(() => {});
   if (q.get('structure') && /^[a-z][a-z0-9-]{0,39}$/.test(q.get('structure'))) { if (!start) start = 'rep'; import('./c3-report-structure.js').then((m) => m.openStructure({ ws: S.ws, id: q.get('structure'), name: '' })).catch(() => { /* the structure step is not available */ }); }
   if (!S.userNav) showTab(start || 'brief', false);   // a press during the read above (the gear, a tab) wins over the start page
   new ResizeObserver(moveInd).observe(S.tabNav);

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

@@ -224,6 +224,7 @@ async function loadOpen(inst) {
   inst.note = r && r.ok ? r.note : null;
   inst.rec = r && r.ok ? r.recording || null : null;
   inst.shots = r && r.ok && r.screen ? r.screen.frames || [] : [];
+  inst.aside = r && r.ok && r.screen ? r.screen.aside || 0 : 0;
   drawRight(inst);
 }
 /** The replay of the note's kept audio: one <audio> per note, kept across redraws so playback goes on. Null when no audio is kept. */
@@ -282,7 +283,7 @@ function drawRight(inst, force) {
   const n = inst.note;
   const live = dock.recordState();
   const held = !!n && live.mode !== 'idle' && live.id === n.id;
-  const sig = JSON.stringify([inst.open, n && [n.updated_at, n.title, n.final_notes && n.final_notes.at, (n.transcript || []).length, (n.highlights || []).length, n.agent && n.agent.markdown, iniName(n.initiative), n.state, n.resume_until, n.ended_at, (n.sessions || []).length, n.meeting && n.meeting.context && n.meeting.context.taken_at], inst.rec && [inst.rec.bytes, inst.rec.cleaned], (inst.shots || []).length, live.mode, live.id, !!inst.rows, inst.ctxOpen, inst.info]);
+  const sig = JSON.stringify([inst.open, n && [n.updated_at, n.title, n.final_notes && n.final_notes.at, (n.transcript || []).length, (n.highlights || []).length, n.agent && n.agent.markdown, iniName(n.initiative), n.state, n.resume_until, n.ended_at, (n.sessions || []).length, n.meeting && n.meeting.context && n.meeting.context.taken_at], inst.rec && [inst.rec.bytes, inst.rec.cleaned], (inst.shots || []).length, inst.aside || 0, live.mode, live.id, !!inst.rows, inst.ctxOpen, inst.info]);
   // a held note draws again on every render: the clock, the lines and the paused minutes move. Nothing else draws without a change.
   if (!force && !held && sig === inst.rightSig) return;
   // a field being typed in is not redrawn under the cursor, except in the live block, whose fields are kept across redraws
@@ -417,7 +418,8 @@ function noteParts(inst, n, live) {
     el('p', { class: 'nt-hint' }, 'Kept on this machine. Press a time in the discussion to play from there.')));
   // the screenshots of the shared screen, on the same clock as the replay and the transcript (notes-screen-capture)
   const shots = held || n.private ? [] : inst.shots || [];
-  if (shots.length) out.push(screenStrip({ id: n.id, frames: shots, seek: replay ? (ms) => seekReplay(inst, ms) : null, replay }));
+  const asideN = held || n.private ? 0 : inst.aside || 0;
+  if (shots.length || asideN) out.push(screenStrip({ id: n.id, frames: shots, aside: asideN, seek: replay ? (ms) => seekReplay(inst, ms) : null, replay }));
 
   const cf = conflictsOf(n);
   if (cf.length) {

package/workspace/public/pm/dest-reports.js

@@ -23,7 +23,7 @@ import { pmGet, pmPost } from './http.js';
 import { watchSig } from './sig-watch.js';
 import { wsOf } from './data.js';
 import { COPY, cadenceName } from './reports-copy.js';
-import { openIssueSheet, openNotesSheet, draftNow, printReport, copyMarkdown, clearPrint, ensurePrintCss } from './report-view.js';
+import { openIssueSheet, openNotesSheet, draftNow, watchDraft, printReport, copyMarkdown, clearPrint, ensurePrintCss } from './report-view.js';
 import { openSlides, slideCards } from './report-slides.js';
 /* The report families and the outbox load on demand: they are only drawn when the PM opens the toggle, and their module tree (the c3
  * panels) must not weigh on the first paint of the Reports page. `lazy()` resolves both modules once. */
@@ -184,6 +184,14 @@ function draftCadence(inst) {
 const knownCadences = (inst) => [...new Set([...inst.reports.map((r) => r.cadence), ...inst.schedules.map((s) => cadenceOfSchedule(s)).filter(Boolean)])].sort();
 
 async function afterDraft(inst, r) {
+  // A draft a session is making (a report with a saved structure): hold the button as Drafting… and watch for the file.
+  if (r && r.ok && r.drafting) {
+    const cad = r.cadence || draftCadence(inst);
+    inst.drafting = inst.drafting || new Set(); inst.drafting.add(cad);
+    watchDraft({ ws: inst.ws, cadence: cad, onDone: async (o) => { inst.drafting.delete(cad); await refresh(inst); if (o.state === 'landed') toast({ text: COPY.draftLanded(cad), timeout: 6000 }); } });
+    await refresh(inst);
+    return;
+  }
   if (r && r.ok && r.slot) inst.sel = (r.cadence || draftCadence(inst)) + ':' + r.slot;
   await refresh(inst);
 }
@@ -195,6 +203,7 @@ function primaryAction(inst) {
       onClick: () => openIssueSheet({ ws: inst.ws, cadence: r.cadence, slot: r.slot, onDone: () => refresh(inst) }) });
   }
   const cadence = draftCadence(inst);
+  if (inst.drafting && inst.drafting.has(cadence)) return button({ label: COPY.draftingLabel, variant: 'primary', disabled: true, attrs: { 'data-rp-act': 'draft-now', 'data-rp-key': 'primary', 'data-rp-drafting': cadence } });
   return button({ label: COPY.draftNow, variant: 'primary', attrs: { 'data-rp-act': 'draft-now', 'data-rp-key': 'primary' },
     onClick: async () => afterDraft(inst, await draftNow({ ws: inst.ws, cadence })) });
 }

package/workspace/public/pm/listen-sheet.js

@@ -0,0 +1,94 @@
+/* listen-sheet.js — the sheets Listen shows before it asks the browser to share (initiative meeting-material-replay, part 3).
+ *
+ *   askListen({ shots }) → Promise<{ app, picture, shots } | null>   "Where is the meeting?": Zoom app, Google Meet in Chrome or Another app,
+ *                                          what PMOS listens to and sees, and Start listening or Sound only. null when the PM closes it.
+ *                                          `shots: false` means Capture the shared screen is off in Settings: the sheet offers sound only.
+ *   askWindow(getStream) → Promise<MediaStream | null>   the second share: "Pick the meeting window". A browser lets a page share only
+ *                                          right after a press, so the button here makes the call itself (getStream). null when skipped.
+ *
+ * The last choice is remembered in localStorage (listen-sources.js recall / remember), wrapped so a blocked store changes nothing.
+ * The words are the mockup's (46-capture.js). Nothing here sends anything: it only draws and answers.
+ */
+import { el } from './dom.js';
+import { button } from './primitives.js';
+import { openSheet, closeSheet } from './c3-sheet.js';
+import { icon, sect, pbtn, plural } from './c3-ini-ui.js';
+import { APPS, planListen, rowsOf, recall, remember } from './listen-sources.js';
+import { ensureListenCss } from './notes-shots.js';
+
+const store = () => { try { return window.localStorage; } catch { return null; } };
+
+const tag = (t, cls) => el('span', { class: 'tag' + (cls ? ' ' + cls : '') }, t);
+function row(r, act) {
+  return el('li', { class: 'nrow', 'data-ls-row': r.icon },
+    el('span', { class: 'ki' + (r.ok ? '' : ' hot') }, icon(r.icon)),
+    el('div', { class: 'nb' }, el('span', { class: 'tt' }, r.title), el('div', { class: 'chips' }, r.tags.map((t, k) => (k === 0 && r.ok ? el('span', { class: 'tag lsn-ok' }, icon('check', 'sm'), t) : tag(t, !r.ok && k === 0 ? 'lsn-warn' : ''))))),
+    act ? el('div', { class: 'acts' }, act) : el('span'));
+}
+
+export function askListen({ shots = true } = {}) {
+  ensureListenCss();
+  return new Promise((resolve) => {
+    const c = recall(store());
+    if (!shots) c.shots = false;
+    let done = false;
+    const finish = (v) => { if (done) return; done = true; resolve(v); };
+    const body = el('div', { class: 'lsn', 'data-ls': 'listen' });
+    openSheet({ title: 'Listen to the meeting', icon: 'mic', wide: true, body, onClose: () => finish(null) });
+    const go = (withShots) => {
+      const choice = { app: c.app, picture: c.picture, shots: withShots };
+      remember(store(), { app: c.app, picture: c.picture, shots: true });   // the place, not the pictures: Sound only is for this meeting
+      finish(choice);
+      closeSheet();
+    };
+    const draw = () => {
+      const plan = planListen(c);
+      const meet = c.app === 'meet';
+      const seg = el('div', { class: 'seg', role: 'group', 'aria-label': 'Meeting app' }, APPS.map((a) => button({ label: a.label, variant: 'ghost', size: 'sm', onClick: () => { c.app = a.id; draw(); }, attrs: { 'aria-pressed': String(c.app === a.id), 'data-ls-app': a.id } })));
+      const rows = rowsOf(plan).map((r) => {
+        if (r.icon === 'eye' && !meet && c.shots) return row(r, pbtn('ghost', 'Change', null, { 'data-ls-pic': 'screen', onclick: () => { c.picture = 'screen'; draw(); } }));
+        if (r.icon === 'alert') return row(r, pbtn('outline', 'Use the meeting window', null, { 'data-ls-pic': 'window', onclick: () => { c.picture = 'window'; draw(); } }));
+        return row(r);
+      });
+      const n = plan.shares.length;
+      const help = !c.shots ? 'PMOS takes no pictures. It still hears the meeting.'
+        : meet ? 'With the PMOS extension in Chrome, Listen starts on the Meet tab in one click, with no sharing window.'
+          : c.picture === 'window' ? 'Pick the meeting window in the second sharing window. When you present, the call shows your slides, so the shots keep them too. Your other apps are never seen.'
+            : 'Shots of other apps are set aside after the meeting for you to keep or delete. They never reach the note, the replay or the agent.';
+      body.replaceChildren(
+        el('p', { class: 'dim cal3-note' }, 'The browser asks you to pick what to share' + (n > 1 ? ', once for each line below' : '') + '. Nothing leaves this machine.'),
+        sect({ ic: 'cal', title: 'Where is the meeting?', right: seg }),
+        sect({ ic: 'eye', title: 'What PMOS listens to and sees', right: el('span', { class: 'dim mono' }, plural(n, 'share')) },
+          el('ul', { class: 'list', role: 'list' }, ...rows), el('p', { class: 'dim lsn-help', 'data-ls-help': '' }, help)),
+        sect({ ic: 'clock', title: 'While it runs' },
+          el('ul', { class: 'list', role: 'list' },
+            row({ icon: 'stop', title: 'Pause shots', tags: ['stops the pictures, keeps the sound', 'on the REC chip and in Focus'], ok: false }),
+            row({ icon: 'lock', title: 'Private', tags: ['stops sound and pictures until you resume'], ok: false }))),
+        el('div', { class: 'iacts' },
+          pbtn('primary', 'Start listening', 'mic', { 'data-ls-go': 'start', onclick: () => go(c.shots) }),
+          shots ? pbtn('ghost', 'Sound only, no shots', null, { 'data-ls-go': 'sound', onclick: () => go(false) }) : null));
+    };
+    draw();
+  });
+}
+
+/** The second share. The button makes the browser call itself, because that call needs a press of its own. */
+export function askWindow(getStream) {
+  ensureListenCss();
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (v) => { if (done) return; done = true; resolve(v); };
+    const msg = el('p', { class: 'dim lsn-help', role: 'status', 'data-ls-msg': '' }, 'The sound is on. Now pick the meeting\'s window, so PMOS can take shots of it only. Your other apps are never seen.');
+    const pick = pbtn('primary', 'Pick the meeting window', 'eye', { 'data-ls-pick': '', onclick: async () => {
+      pick.disabled = true;
+      let s = null;
+      try { s = await getStream(); } catch { s = null; }
+      if (!s) { msg.textContent = 'No window was picked. Pick it again, or listen to the sound only.'; pick.disabled = false; return; }
+      finish(s);
+      closeSheet();
+    } });
+    const body = el('div', { class: 'lsn', 'data-ls': 'window' }, msg,
+      el('div', { class: 'iacts' }, pick, pbtn('ghost', 'Sound only, no shots', null, { 'data-ls-skip': '', onclick: () => { finish(null); closeSheet(); } })));
+    openSheet({ title: 'Pick the meeting window', icon: 'eye', body, onClose: () => finish(null) });
+  });
+}

package/workspace/public/pm/listen-sources.js

@@ -0,0 +1,82 @@
+/* listen-sources.js — where the meeting is, and which browser shares Listen asks for (initiative meeting-material-replay, part 3).
+ *
+ *   APPS                                    the three places a meeting can be: Zoom app, Google Meet in Chrome, Another app
+ *   normalize(choice) → { app, picture, shots }   a choice with every field in its range
+ *   planListen(choice) → plan               the shares to ask for and what each one is used for
+ *   surfaceOf(track, planned) → 'window' | 'browser' | 'monitor' | null   what the picture really is
+ *   recall(storage) · remember(storage, choice)   the last choice, kept on this machine
+ *   rowsOf(plan) → [{ icon, title, tags, ok }]    the lines the Listen sheet shows
+ *
+ * WHY SEPARATE SHARES. Only the whole screen carries the sound of Zoom, but its picture holds every app the PM switches to. So for Zoom
+ * or another app the SOUND comes from one share of the whole screen with system audio (its picture is never used) and the PICTURE from a
+ * second share of the meeting's window only, which stays captured while the PM works in other apps. The second share needs its own press,
+ * and it can be skipped (sound only). Google Meet is a tab: one share of that tab carries both. The PM can still choose the whole screen
+ * as the picture; then the safety net in lib/notes-screen.js sets aside the shots that look like another app.
+ *
+ * Pure: no DOM and no network, so the unit test (listen-sources.test.js) imports it from node.
+ */
+export const APPS = [
+  { id: 'zoom', label: 'Zoom app' },
+  { id: 'meet', label: 'Google Meet in Chrome' },
+  { id: 'other', label: 'Another app' },
+];
+export const KEY = 'pmos.listen.where';
+const SURFACES = ['window', 'browser', 'monitor'];
+const AUDIO = { echoCancellation: false, noiseSuppression: false, autoGainControl: false };
+
+/** The three options of one choice, each in its range. The default is the Zoom app with the picture from its window. */
+export function normalize(c) {
+  const o = c && typeof c === 'object' ? c : {};
+  return {
+    app: APPS.some((a) => a.id === o.app) ? o.app : 'zoom',
+    picture: o.picture === 'screen' ? 'screen' : 'window',
+    shots: o.shots !== false,
+  };
+}
+
+/** getDisplayMedia options for one share. Chrome ignores a hint it does not know. */
+export function shareOptions(role, app) {
+  if (role === 'picture') return { video: { displaySurface: 'window' }, audio: false, monitorTypeSurfaces: 'exclude', surfaceSwitching: 'exclude', selfBrowserSurface: 'exclude' };
+  if (app === 'meet') return { video: { displaySurface: 'browser' }, audio: { ...AUDIO }, monitorTypeSurfaces: 'exclude', surfaceSwitching: 'include', selfBrowserSurface: 'exclude' };
+  return { video: { displaySurface: 'monitor' }, audio: { ...AUDIO }, systemAudio: 'include', monitorTypeSurfaces: 'include', surfaceSwitching: 'include', selfBrowserSurface: 'exclude' };
+}
+
+/** The shares Listen asks for. Each share says its role ('sound' | 'picture' | 'both'), whether its picture and its sound are used,
+ * and whether the PM may skip it. `surface` is what the pictures show: the meeting's window, the Meet tab, the whole screen, or null (no pictures). */
+export function planListen(choice) {
+  const c = normalize(choice);
+  const share = (role, keepVideo, keepAudio, optional = false) => ({ role, options: shareOptions(role, c.app), keepVideo, keepAudio, optional });
+  if (c.app === 'meet') return { ...c, shares: [share('both', c.shots, true)], surface: c.shots ? 'browser' : null };
+  if (!c.shots) return { ...c, shares: [share('sound', false, true)], surface: null };
+  if (c.picture === 'screen') return { ...c, shares: [share('both', true, true)], surface: 'monitor' };
+  return { ...c, shares: [share('sound', false, true), share('picture', true, false, true)], surface: 'window' };
+}
+
+/** What the picture really is: the browser's own word for the share when it gives one, else what was asked for. Null when neither is known. */
+export function surfaceOf(track, planned) {
+  let s = null;
+  try { s = track && typeof track.getSettings === 'function' ? track.getSettings().displaySurface : null; } catch { s = null; }
+  if (SURFACES.includes(s)) return s;
+  return SURFACES.includes(planned) ? planned : null;
+}
+
+/** The last choice, from a Storage (localStorage). Anything wrong with storage gives the default. */
+export function recall(storage) {
+  try { const raw = storage && storage.getItem(KEY); return normalize(raw ? JSON.parse(raw) : null); } catch { return normalize(null); }
+}
+export function remember(storage, choice) {
+  try { if (!storage) return false; storage.setItem(KEY, JSON.stringify(normalize(choice))); return true; } catch { return false; }
+}
+
+/** The lines the sheet shows for a choice: what is heard and what is seen. */
+export function rowsOf(plan) {
+  const p = plan && plan.shares ? plan : planListen(plan);
+  const win = p.app === 'zoom' ? 'Zoom Meeting' : 'meeting app\'s';
+  if (p.app === 'meet') {
+    return [{ icon: 'mic', title: p.shots ? 'Sound and picture: the Meet tab' : 'Sound: the Meet tab', tags: ['tab audio on', p.shots ? 'only this tab is seen' : 'no pictures'], ok: true }];
+  }
+  const sound = { icon: 'vol', title: 'Sound: Entire screen, with system audio', tags: ['hears every app, so ' + (p.app === 'zoom' ? 'Zoom' : 'your meeting app') + ' too', p.picture === 'screen' && p.shots ? 'its picture is kept' : 'its picture is not kept'], ok: true };
+  if (!p.shots) return [sound, { icon: 'eye', title: 'Picture: none', tags: ['sound only, no shots'], ok: true }];
+  if (p.picture === 'screen') return [sound, { icon: 'alert', title: 'Picture: Entire screen', tags: ['every app you switch to is on it', 'PMOS keeps only shots that look like the call'], ok: false }];
+  return [sound, { icon: 'eye', title: 'Picture: the ' + win + ' window', tags: ['only this window is seen', 'still captured while you are in other apps'], ok: true }];
+}