create-pmos 0.53.0 → 0.53.2

package/workspace/public/pm/report-slides.js

@@ -0,0 +1,438 @@
+/* pm/report-slides.js — the biweekly as slides (pm-os-absorb Run 6; PRD R22.7, open question Q3 answered "slides").
+ *
+ * The PM asked for the PM-OS biweekly deck, cut to four kinds of slide (2026-10-06): the roadmap snapshot, the
+ * initiative list, one slide per initiative and the changelog. Each is drawn on the PM-OS canvas: 1280 × 720, a
+ * numbered blue header band, a footer with the page number and the report's name.
+ *
+ * The slides read the report file and nothing else. The drafter (lib/report-draft.js) folds the facts into one
+ * `<!-- pmos:slides v1 {json} -->` block at the end of the draft, so an issued report freezes its slides with its
+ * text. The PM's words are the note markers: an initiative's note is the box on its slide, and `report.changelog` is
+ * the release notes. This file computes no fact and writes nothing.
+ *   slidesOf(md)          the report as a list of slides (pure, no DOM); [] when the file has no slides block
+ *   renderSlide(s)        one slide as DOM nodes, at 1280 × 720
+ *   slideCards(md)        every slide, scaled to the width of the Reports viewer
+ *   openSlides({ md })    Present: full screen on black; arrow keys, Space, PageUp/PageDown, Home/End, a swipe, Escape
+ *   printSlides(md)       every slide on its own 1280 × 720 page (print.css), then window.print()
+ */
+
+import { el } from './dom.js';
+import { button, iconButton, layer, ensureComponentsCss } from './primitives.js';
+import { icon, ensureSprite } from './icons.js';
+import { parseReport, ensurePrintCss, clearPrint } from './report-view.js';
+import { COPY } from './slides-copy.js';
+
+export const W = 1280;                                 // the PM-OS slide canvas, in CSS px (13.333in × 7.5in on paper)
+export const H = 720;
+const ROADMAP_LINES = 9;                               // group and initiative rows on one roadmap slide (52px each)
+const LIST_ROWS = 10;                                  // initiatives on one list slide (49px each)
+const COLUMN_CAP = 6;                                  // items in a Last / Next cycle column before "+N more"
+const NOTE_LINES = 4;                                  // lines in an initiative's note box
+const CHANGELOG_BUDGET = 560;                          // px of release notes on one changelog slide
+const SLIDES_RE = /<!-- pmos:slides v1 (\{[^\n]*\}) -->\s*$/;   // the drafter's block: one line, last in the file
+const STAGE_TONE = { intake: 'intake', brief: 'intake', spec: 'spec', draft: 'spec', contract: 'spec', build: 'build', evaluate: 'evaluate', handoff: 'handoff' };
+const EARLY = /^(intake|brief|spec|draft|contract|unknown)$/i;   // a lifecycle badge before the build reads muted
+const TYPES = ['launch', 'improvement', 'fix', 'security', 'deprecation', 'beta'];
+const KINDS = ['added', 'changed', 'fixed', 'deprecated', 'security', 'removed'];
+
+/* ── dates, the PM-OS way ─────────────────────────────────────────────────────────────────────────────────────────── */
+
+const utc = (ymd) => new Date(String(ymd).slice(0, 10) + 'T00:00:00Z');
+const fmt = (ymd, opts, loc = 'en-GB') => utc(ymd).toLocaleDateString(loc, { timeZone: 'UTC', ...opts });
+const dayBefore = (ymd) => new Date(utc(ymd).getTime() - 86400000).toISOString().slice(0, 10);
+/** "10 Jun 26" */
+export const msDate = (ymd) => (ymd ? fmt(ymd, { day: 'numeric', month: 'short', year: '2-digit' }) : '');
+/** "28 Sept → 4 Oct"; inside one month "5 Oct → 11". Both ends are included. */
+export function rangeText(from, to) {
+  if (!from || !to) return '';
+  const a = fmt(from, { day: 'numeric', month: 'short' });
+  return from.slice(0, 7) === to.slice(0, 7) ? a + ' → ' + Number(to.slice(8, 10)) : a + ' → ' + fmt(to, { day: 'numeric', month: 'short' });
+}
+const longDate = (ymd) => fmt(ymd, { day: 'numeric', month: 'long', year: 'numeric' });
+const monthName = (ym) => fmt(ym + '-01', { month: 'short' }, 'en-US');
+const monthTitle = (ymd) => fmt(ymd, { month: 'long', year: 'numeric' }, 'en-US');
+
+/* ── the report as slides (pure) ──────────────────────────────────────────────────────────────────────────────────── */
+
+/** The slides block of the report, or null when the file has none (a draft from before Run 6, or a hand-written one). */
+export function slidesBlock(md) {
+  const m = SLIDES_RE.exec(String(md || '').replace(/\r\n/g, '\n'));
+  if (!m) return null;
+  try { const d = JSON.parse(m[1]); return d && d.v === 1 ? d : null; } catch { return null; }
+}
+
+/** The release notes the PM writes in `report.changelog`. Entries are separated by a blank line:
+ *    Launch · Sign-in: Email codes for every title (2026-10-02)
+ *    Readers can sign in with a one-time code.
+ *    - Added: Code entry screen
+ *  The first line is `Type[ · Area]: Title[ (YYYY-MM-DD)]`; a plain line is the summary; `- Kind: text` is a change. */
+export function parseChangelog(text, fallbackDate) {
+  // Line by line, not paragraph by paragraph: md-newlines --fix joins a paragraph into one line and puts a blank line
+  // before a list, so an entry must read the same with or without blank lines. An entry starts on a typed head line
+  // ("Launch · Area: Title"), or on a plain line after a blank line once the entry before has a summary or a change.
+  const out = [];
+  let e = null; let gap = true;
+  for (const raw of String(text || '').replace(/\r\n/g, '\n').split('\n')) {
+    const ln = raw.trim().replace(/^#{1,6}\s+/, '');
+    if (!ln) { gap = true; continue; }
+    const head = /^([A-Za-z]+)(?:\s*·\s*([^:]+?))?\s*:\s*(.+?)(?:\s*\((\d{4}-\d{2}-\d{2})\))?$/.exec(ln);
+    const c = /^-\s+([A-Za-z]+)\s*:\s*(.+)$/.exec(ln);
+    const item = /^-\s+/.test(ln);
+    if (head && !item && TYPES.includes(head[1].toLowerCase())) {
+      e = { type: head[1].toLowerCase(), area: head[2] ? head[2].trim() : '', title: head[3].trim(), date: head[4] || fallbackDate, summary: [], changes: [] };
+      out.push(e);
+    } else if (!e || (!item && gap && (e.summary.length || e.changes.length))) {
+      e = { type: 'improvement', area: '', title: ln.replace(/^-\s+/, ''), date: fallbackDate, summary: [], changes: [] };
+      out.push(e);
+    } else if (c && KINDS.includes(c[1].toLowerCase())) e.changes.push({ kind: c[1].toLowerCase(), text: c[2].trim() });
+    else if (item) e.changes.push({ kind: 'changed', text: ln.replace(/^-\s+/, '') });
+    else e.summary.push(ln);
+    gap = false;
+  }
+  for (const x of out) x.summary = x.summary.join(' ');
+  return out.sort((a, b) => (a.date < b.date ? 1 : a.date > b.date ? -1 : 0));
+}
+
+/** Roadmap lines, nine to a slide: a slide never ends on a group label, and a group that runs on repeats its label. */
+function roadmapPages(lines) {
+  const pages = [[]];
+  for (const ln of lines) {
+    let cur = pages[pages.length - 1];
+    const room = ROADMAP_LINES - cur.length;
+    if (room <= 0 || (!ln.row && room <= 1)) { cur = []; pages.push(cur); if (ln.row) cur.push({ group: ln.group }); }
+    cur.push(ln);
+  }
+  return pages;
+}
+
+const chunks = (xs, n) => { const out = []; for (let i = 0; i < xs.length; i += n) out.push(xs.slice(i, i + n)); return out.length ? out : [[]]; };
+
+/** The height one release-notes entry takes, near enough to fill a slide without running off it. */
+const entryHeight = (e) => 20 + 30 + Math.ceil((e.summary || '').length / 150) * 23 + e.changes.length * 24 + 28;
+
+/** "northwind  |  Biweekly · 16 Oct → 29 | 16 October 2026" */
+function footOf(meta) {
+  return meta.product + '  |  ' + meta.cadence + ' · ' + rangeText(meta.next.from, dayBefore(meta.next.to)) + ' | ' + longDate(meta.slot || meta.today);
+}
+
+/** The report as slides. Pure: the same file gives the same slides. Each slide carries its own number. */
+export function slidesOf(md) {
+  const d = slidesBlock(md);
+  if (!d) return [];
+  const notes = new Map(parseReport(md).filter((b) => b.t === 'note').map((b) => [b.id, b.text.trim()]));
+  const slides = [];
+
+  // 1. the roadmap snapshot: group label lines and initiative lines, nine to a slide
+  const lines = [];
+  for (const g of d.roadmap.groups) { lines.push({ group: g.name }); for (const r of g.rows) lines.push({ group: g.name, row: r }); }
+  for (const part of roadmapPages(lines)) slides.push({ kind: 'roadmap', title: COPY.roadmap, months: d.roadmap.months, today: d.roadmap.today, lines: part });
+
+  // 2. the initiative list, ten to a slide
+  for (const part of chunks(d.list, LIST_ROWS)) slides.push({ kind: 'list', title: COPY.list, rows: part, today: d.meta.today });
+
+  // 3. one slide per initiative, its note in the box
+  for (const x of d.initiatives) slides.push({ kind: 'initiative', title: x.title, init: x, note: notes.get(x.id) || '', meta: d.meta });
+
+  // 4. the changelog: the PM's own release notes, typed into the report.changelog note; nothing written, nothing shown
+  const entries = parseChangelog(notes.get('report.changelog'), d.meta.today);
+  const pages = [[]];
+  let used = 0;
+  for (const e of entries) {
+    const h = entryHeight(e) + 36;
+    if (used + h > CHANGELOG_BUDGET && pages[pages.length - 1].length) { pages.push([]); used = 0; }
+    pages[pages.length - 1].push(e); used += h;
+  }
+  for (const part of pages) slides.push({ kind: 'changelog', title: COPY.changelog, entries: part });
+
+  slides.forEach((s, i) => { s.n = i + 1; s.foot = footOf(d.meta); });
+  return slides;
+}
+
+/* ── one slide as DOM ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const pad2 = (n) => String(n).padStart(2, '0');
+const span = (cls, text) => el('span', { class: cls }, text);
+const glyph = (name, cls) => el('span', { class: cls, 'aria-hidden': 'true' }, icon(name));
+/** Run-time geometry, as the layout's own custom properties (R28-1). */
+function placed(node, vars) { for (const [k, v] of Object.entries(vars)) node.style.setProperty(k, v); return node; }
+
+function frame(s, body) {
+  return el('section', { class: 'rp-slide rp-slide--' + s.kind, 'data-slide': s.kind, 'aria-roledescription': 'slide', 'aria-label': s.title },
+    el('header', { class: 'rp-slide__header' },
+      el('div', { class: 'rp-slide__num' }, pad2(s.n)),
+      el('div', { class: 'rp-slide__band' }, el('h2', { class: 'rp-slide__title' }, s.title))),
+    el('div', { class: 'rp-slide__body' }, body),
+    el('footer', { class: 'rp-slide__footer' },
+      span('rp-slide__page', pad2(s.n)), span('rp-slide__meta', s.foot)));
+}
+
+/* the roadmap: a 300px column of names, then six months of bars */
+const MONTH_W = (1212 - 300) / 6;
+function xOf(months, ymd) {
+  const ym = ymd.slice(0, 7);
+  const k = months.indexOf(ym);
+  if (k < 0) return ym < months[0] ? -8 : months.length * MONTH_W + 8;
+  const days = new Date(Date.UTC(Number(ym.slice(0, 4)), Number(ym.slice(5, 7)), 0)).getUTCDate();
+  return (k + (Number(ymd.slice(8, 10)) - 1) / days) * MONTH_W;
+}
+const DAY_W = MONTH_W / 30;
+const pos = (left, width) => ({ '--rp-x': Math.round(left) + 'px', '--rp-w': Math.max(4, Math.round(width)) + 'px' });
+
+function roadmapBody(s) {
+  const names = el('div', { class: 'rp-slide__gnames' },
+    el('div', { class: 'rp-slide__ghead' }, el('p', { class: 'rp-slide__gissues' }, COPY.issues), el('p', { class: 'rp-slide__gdur' }, COPY.duration)));
+  const lanes = el('div', { class: 'rp-slide__glanes' },
+    s.months.map((ym, k) => placed(el('div', { class: 'rp-slide__gcol' },
+      k === 0 || ym.endsWith('-01') ? el('p', { class: 'rp-slide__gyear' }, ym.slice(0, 4)) : null,
+      el('p', { class: 'rp-slide__gmonth' }, monthName(ym))), pos(k * MONTH_W, MONTH_W))));
+  const rows = el('div', { class: 'rp-slide__grows' });
+  lanes.appendChild(rows);
+  for (const ln of s.lines) {
+    if (!ln.row) {
+      names.appendChild(el('p', { class: 'rp-slide__glabel' }, ln.group));
+      rows.appendChild(el('div', { class: 'rp-slide__gline' }));
+      continue;
+    }
+    const r = ln.row;
+    names.appendChild(el('div', { class: 'rp-slide__gname', 'data-init': r.id },
+      glyph('chevron-right', 'rp-slide__gchev'),
+      el('span', { class: 'rp-slide__ldot rp-slide__ldot--' + ln.group.toLowerCase() }),
+      el('span', { class: 'rp-slide__gtitle' }, r.title)));
+    const line = el('div', { class: 'rp-slide__gline', 'data-init': r.id });
+    if (r.segments.length) {
+      const x0 = xOf(s.months, r.segments.reduce((a, g) => (g.start < a ? g.start : a), r.segments[0].start));
+      const x1 = xOf(s.months, r.segments.reduce((a, g) => (g.due > a ? g.due : a), r.segments[0].due)) + DAY_W;
+      const bar = placed(el('div', { class: 'rp-slide__gbar' }), pos(x0 - 6, x1 - x0 + 12));
+      for (const g of r.segments) {
+        const a = xOf(s.months, g.start); const b = xOf(s.months, g.due) + DAY_W;
+        bar.appendChild(placed(el('span', {
+          class: 'rp-slide__gseg rp-slide__gseg--' + (STAGE_TONE[g.stage] || 'other') + (r.estimated ? ' rp-slide__gseg--est' : ''),
+          'data-stage': g.label, title: g.label + ' · ' + msDate(g.start) + ' → ' + msDate(g.due),
+        }), pos(a - x0 + 6, b - a)));
+      }
+      line.appendChild(bar);
+    }
+    rows.appendChild(line);
+  }
+  return el('div', { class: 'rp-slide__gantt' }, names, lanes);
+}
+
+/* the initiative list */
+const badge = (status) => el('span', { class: 'rp-slide__badge' + (EARLY.test(status || '') ? ' rp-slide__badge--early' : '') }, status || '');
+const dash = () => span('rp-slide__dash', '—');
+function milestoneCell(m, today) {
+  if (!m) return el('div', { class: 'rp-slide__td rp-slide__td--ms' }, dash());
+  const late = m.due < today;
+  return el('div', { class: 'rp-slide__td rp-slide__td--ms' },
+    el('p', { class: 'rp-slide__mstitle' }, m.title),
+    el('p', { class: 'rp-slide__msdue' + (late ? ' rp-slide__msdue--late' : '') }, late ? COPY.overdue(msDate(m.due)) : msDate(m.due)));
+}
+function listBody(s) {
+  const head = el('div', { class: 'rp-slide__tr rp-slide__tr--head' },
+    el('div', { class: 'rp-slide__th' }, COPY.initiative), el('div', { class: 'rp-slide__th rp-slide__th--caps' }, COPY.status),
+    el('div', { class: 'rp-slide__th' }, COPY.nextMilestone), el('div', { class: 'rp-slide__th' }, COPY.release));
+  const rows = s.rows.map((x) => el('div', { class: 'rp-slide__tr', 'data-init': x.id },
+    el('div', { class: 'rp-slide__td rp-slide__td--name' }, x.title),
+    el('div', { class: 'rp-slide__td' }, badge(x.status)),
+    milestoneCell(x.next_milestone, s.today),
+    el('div', { class: 'rp-slide__td rp-slide__td--rel' }, x.release ? msDate(x.release) : dash())));
+  return el('div', { class: 'rp-slide__table' }, head, s.rows.length ? rows : el('p', { class: 'rp-slide__empty rp-slide__empty--list' }, COPY.noInitiatives));
+}
+
+/* one initiative */
+function itemRow(it) {
+  const mark = it.milestone ? el('span', { class: 'rp-slide__mark rp-slide__mark--ms', 'aria-hidden': 'true' })
+    : it.done ? glyph('check', 'rp-slide__mark rp-slide__mark--done') : el('span', { class: 'rp-slide__mark rp-slide__mark--open', 'aria-hidden': 'true' });
+  const sub = it.milestone
+    ? [span('rp-slide__subms', COPY.milestone), it.date ? ' · ' + msDate(it.date) : '', it.owner ? ' · ' + it.owner : '']
+    : [it.stage || '', it.owner ? ' · ' + it.owner : ''];
+  return el('li', { class: 'rp-slide__item' + (it.milestone ? ' rp-slide__item--ms' : ''), 'data-done': it.done ? 'true' : 'false' }, mark,
+    el('div', { class: 'rp-slide__itext' }, el('p', { class: 'rp-slide__ititle' }, it.title), el('p', { class: 'rp-slide__isub' }, sub)));
+}
+function cycleColumn(key, title, range, items, empty) {
+  const sorted = [...items.filter((x) => x.milestone), ...items.filter((x) => !x.milestone)];
+  return el('div', { class: 'rp-slide__ccol', 'data-cycle': key },
+    el('div', { class: 'rp-slide__chead' }, el('h3', { class: 'rp-slide__ctitle' }, title), span('rp-slide__crange', range)),
+    sorted.length
+      ? el('ul', { class: 'rp-slide__items' }, sorted.slice(0, COLUMN_CAP).map(itemRow),
+        sorted.length > COLUMN_CAP ? el('li', { class: 'rp-slide__more' }, COPY.more(sorted.length - COLUMN_CAP)) : null)
+      : el('p', { class: 'rp-slide__empty' }, empty));
+}
+function noteBox(text) {
+  if (!text) return null;
+  const m = /^(note|info|warning)\s*:\s*/i.exec(text);
+  const type = m ? m[1].toLowerCase() : 'note';
+  const lines = text.slice(m ? m[0].length : 0).split('\n').map((l) => l.replace(/^[-*]\s+/, '').trim()).filter(Boolean);
+  return el('div', { class: 'rp-slide__note rp-slide__note--' + type, 'data-note-type': type },
+    el('p', { class: 'rp-slide__notehead' }, COPY.noteType[type]),
+    el('ul', { class: 'rp-slide__notelist' }, lines.slice(0, NOTE_LINES).map((l) => el('li', { class: 'rp-slide__noteli' }, l))));
+}
+function initiativeBody(s) {
+  const x = s.init; const m = s.meta;
+  const top = el('div', { class: 'rp-slide__itop' }, badge(x.status),
+    x.pct === null ? el('p', { class: 'rp-slide__pct rp-slide__pct--none' }, COPY.noBreakdown) : el('div', { class: 'rp-slide__prog' },
+      el('div', { class: 'rp-slide__track' }, placed(el('div', { class: 'rp-slide__fill' }), { '--rp-pct': x.pct + '%' })),
+      el('p', { class: 'rp-slide__pct' }, x.pct + '%')));
+  const ms = x.next_milestone;
+  const late = ms && ms.due < m.today;
+  const msLine = el('div', { class: 'rp-slide__msline' },
+    span('rp-slide__mslabel', COPY.nextMilestone),
+    ms ? span('rp-slide__msname', ms.title) : dash(),
+    ms ? span('rp-slide__mswhen' + (late ? ' rp-slide__mswhen--late' : ''), late ? COPY.overdue(msDate(ms.due)) : msDate(ms.due)) : null,
+    span('rp-slide__mslabel rp-slide__mslabel--rel', COPY.release),
+    x.release ? span('rp-slide__msname', msDate(x.release)) : dash());
+  return [top, msLine,
+    el('div', { class: 'rp-slide__cycles' },
+      cycleColumn('last', COPY.lastCycle, rangeText(m.last.from, dayBefore(m.last.to)), x.last, COPY.nothingShipped),
+      cycleColumn('next', COPY.nextCycle, rangeText(m.next.from, dayBefore(m.next.to)), x.next, COPY.nothingPlanned)),
+    noteBox(s.note)];
+}
+
+/* release notes */
+function changelogBody(s) {
+  if (!s.entries.length) return el('p', { class: 'rp-slide__empty' }, COPY.noReleaseNotes);
+  const out = [];
+  let month = null; let list = null;
+  for (const e of s.entries) {
+    const ym = e.date.slice(0, 7);
+    if (ym !== month) {
+      month = ym;
+      const n = s.entries.filter((y) => y.date.slice(0, 7) === ym).length;
+      out.push(el('h3', { class: 'rp-slide__month' }, monthTitle(e.date), span('rp-slide__mcount', COPY.entries(n))));
+      list = el('ol', { class: 'rp-slide__timeline' });
+      out.push(list);
+    }
+    list.appendChild(el('li', { class: 'rp-slide__entry rp-slide__entry--' + e.type, 'data-entry-type': e.type },
+      el('span', { class: 'rp-slide__edot', 'aria-hidden': 'true' }),
+      el('div', { class: 'rp-slide__erow' },
+        span('rp-slide__pill', e.label || e.type),
+        e.area ? span('rp-slide__area', e.area) : null,
+        el('time', { class: 'rp-slide__edate', datetime: e.date }, fmt(e.date, { month: 'short', day: 'numeric', year: 'numeric' }, 'en-US'),
+          span('rp-slide__eday', ' · ' + fmt(e.date, { weekday: 'long' }, 'en-US')))),
+      el('h4', { class: 'rp-slide__etitle' }, e.title),
+      e.summary ? el('p', { class: 'rp-slide__esum' }, e.summary) : null,
+      e.changes.map((c) => el('p', { class: 'rp-slide__change' }, span('rp-slide__kind rp-slide__kind--' + c.kind, c.kind), span('rp-slide__ctext', c.text)))));
+  }
+  return out;
+}
+
+const BODY = { roadmap: roadmapBody, list: listBody, initiative: initiativeBody, changelog: changelogBody };
+
+/** One slide, 1280 × 720. */
+export function renderSlide(s) {
+  ensureSprite();
+  return frame(s, BODY[s.kind](s));
+}
+
+/* ── in the Reports viewer: the slides, one under the other, scaled to the column ────────────────────────────────── */
+
+const fitTo = (host, width) => host.style.setProperty('--rp-scale', String(Math.max(0.05, Math.round((width / W) * 10000) / 10000)));
+
+/** Every slide of the report as a card the width of the column. A file with no slides block says how to get them. */
+export function slideCards(md) {
+  ensureComponentsCss();
+  const slides = slidesOf(md);
+  if (!slides.length) return el('p', { class: 'rp-section__empty', 'data-rp-noslides': '' }, COPY.slidesMissing);
+  const host = el('div', { class: 'rp-slides', role: 'list', 'aria-label': COPY.slidesTitle },
+    slides.map((s) => el('div', { class: 'rp-slides__card', role: 'listitem', 'data-slide-n': String(s.n) }, renderSlide(s))));
+  if (typeof ResizeObserver === 'function') {
+    const ro = new ResizeObserver((es) => { for (const e of es) if (e.contentRect.width) fitTo(host, e.contentRect.width); });
+    ro.observe(host);
+  }
+  return host;
+}
+
+/* ── on paper: one slide per 1280 × 720 page ──────────────────────────────────────────────────────────────────────── */
+
+/** Draw every slide into `body > .rp-print.rp-print--slides` and print. print.css gives each slide its own page. */
+export function printSlides(md) {
+  ensureComponentsCss();
+  ensurePrintCss();
+  clearPrint();
+  const host = el('div', { class: 'rp-print rp-print--slides', 'aria-hidden': 'true' }, slidesOf(md).map((s) => renderSlide(s)));
+  document.body.appendChild(host);
+  const drop = () => { host.remove(); window.removeEventListener('afterprint', drop); };
+  window.addEventListener('afterprint', drop);
+  try { window.print(); } catch { drop(); }
+}
+
+/* ── Present ──────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/**
+ * openSlides({ md, label, start?, printable?, returnFocus? }): the deck, full screen on black, one slide fitted. ← → Space PageUp PageDown Home
+ * End move; a horizontal swipe of 40px moves; Escape or Close ends it. Returns { dialog, go(i), close, index, count }.
+ */
+export function openSlides({ md, label, start = 0, printable = false, returnFocus = null } = {}) {
+  ensureComponentsCss();
+  ensureSprite();
+  const slides = slidesOf(md);
+  let i = Math.min(Math.max(0, start), Math.max(0, slides.length - 1));
+  let closed = false;
+  const stage = el('div', { class: 'rp-deck__stage' });
+  const frameEl = el('div', { class: 'rp-deck__frame', 'aria-live': 'polite' });
+  stage.appendChild(frameEl);
+  const count = el('p', { class: 'rp-deck__count' });
+  const prev = iconButton({ icon: 'chevron-left', ariaLabel: COPY.slidesPrev, attrs: { 'data-rp-act': 'slide-prev' }, onClick: () => go(i - 1) });
+  const next = iconButton({ icon: 'chevron-right', ariaLabel: COPY.slidesNext, attrs: { 'data-rp-act': 'slide-next' }, onClick: () => go(i + 1) });
+  // Print / PDF only for an issued report: a report leaves the workspace after Issue, never as a draft (D71)
+  const print = printable ? button({ label: COPY.print, variant: 'ghost', size: 'sm', attrs: { 'data-rp-act': 'slides-print' }, onClick: () => printSlides(md) }) : null;
+  const shut = iconButton({ icon: 'x', ariaLabel: COPY.slidesClose, attrs: { 'data-rp-act': 'slides-close' }, onClick: () => close() });
+  const bar = el('div', { class: 'rp-deck__bar', role: 'toolbar', 'aria-label': label || COPY.slidesTitle },
+    el('p', { class: 'rp-deck__label' }, label || COPY.slidesTitle), prev, count, next, print, shut);
+  const dialog = el('dialog', { class: 'rp-deck', 'aria-modal': 'true', 'aria-label': label || COPY.slidesTitle, 'aria-roledescription': 'carousel', tabindex: '-1' }, stage, bar);
+
+  const fit = () => {
+    const r = stage.getBoundingClientRect();
+    const k = Math.max(0.05, Math.min(r.width / W, r.height / H));
+    dialog.style.setProperty('--rp-scale', String(Math.round(k * 10000) / 10000));
+  };
+  function go(to) {
+    if (!slides.length) {
+      frameEl.replaceChildren(el('p', { class: 'rp-deck__empty' }, COPY.slidesMissing));
+      count.textContent = ''; prev.disabled = true; next.disabled = true;
+      return;
+    }
+    i = Math.min(Math.max(0, to), slides.length - 1);
+    frameEl.replaceChildren(renderSlide(slides[i]));
+    count.textContent = COPY.slidesCount(i + 1, slides.length);
+    const was = document.activeElement;
+    prev.disabled = i === 0;
+    next.disabled = i === slides.length - 1;
+    // a button that was just disabled loses the focus to the page: keep it in the deck, so the keys still move
+    if ((was === prev && prev.disabled) || (was === next && next.disabled)) dialog.focus();
+  }
+  function close() {
+    if (closed) return;
+    closed = true;
+    window.removeEventListener('resize', fit);
+    try { if (dialog.open) dialog.close(); } catch { /* already closed */ }
+    dialog.remove();
+    if (returnFocus && returnFocus.isConnected) returnFocus.focus();
+  }
+  dialog.addEventListener('cancel', (e) => { e.preventDefault(); close(); });
+  dialog.addEventListener('keydown', (e) => {
+    const k = e.key;
+    if (k === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); }
+    else if (k === 'ArrowRight' || k === 'PageDown' || (k === ' ' && !(e.target && e.target.closest && e.target.closest('button')))) { e.preventDefault(); go(i + 1); }
+    else if (k === 'ArrowLeft' || k === 'PageUp') { e.preventDefault(); go(i - 1); }
+    else if (k === 'Home') { e.preventDefault(); go(0); }
+    else if (k === 'End') { e.preventDefault(); go(slides.length - 1); }
+  });
+  // a swipe: touch, not pointer, so a mouse drag selects text as usual; the buttons are the way for a mouse and a keyboard
+  let x0 = null; let y0 = null;
+  stage.addEventListener('touchstart', (e) => { const t = e.changedTouches[0]; x0 = t.clientX; y0 = t.clientY; }, { passive: true });
+  stage.addEventListener('touchend', (e) => {
+    if (x0 === null) return;
+    const t = e.changedTouches[0];
+    const dx = t.clientX - x0; const dy = t.clientY - y0;
+    x0 = null;
+    if (Math.abs(dx) > 40 && Math.abs(dx) > 1.5 * Math.abs(dy)) go(i + (dx < 0 ? 1 : -1));
+  }, { passive: true });
+
+  layer().appendChild(dialog);
+  dialog.showModal();
+  window.addEventListener('resize', fit);
+  fit();
+  go(i);
+  dialog.focus();
+  return { dialog, go, close, get index() { return i; }, get count() { return slides.length; } };
+}

package/workspace/public/pm/report-view.js

@@ -6,7 +6,8 @@
  *   noteSlots(md)            [{ id, title, text }] the notes the PM can edit, in the order they appear
  *   markdownToCopy(md)       the markdown without its frontmatter and note markers, for Copy as markdown
  *   copyMarkdown(md)         put that on the clipboard, then toast
- *   printReport(md)          draw the report into `body > .rp-print` and call window.print(); print.css shows only it
+ *   printReport(md)          print the report's slides (report-slides.js), or for a file with none draw the text into
+ *                            `body > .rp-print`; then window.print(), and print.css shows only it
  *   openIssueSheet(args)     the two-tap Issue: the sheet reads the draft, the PM presses Issue, the file is frozen
  *   openNotesSheet(args)     one sheet for every note of the draft
  *   draftNow(args)           POST /api/report/draft, then toast
@@ -24,6 +25,7 @@ import { ensureSprite } from './icons.js';
 import { pmGet, pmPost } from './http.js';
 import { registerTodayCard } from './registry.js';
 import { COPY } from './reports-copy.js';
+import { slidesBlock, printSlides } from './report-slides.js';
 
 /* ── the markdown subset the drafter writes ───────────────────────────────────────────────────────────────────────── */
 
@@ -31,7 +33,9 @@ const NOTE_RE = /<!-- pmos:note ([a-z0-9][a-z0-9._-]*) -->\n?([\s\S]*?)\n?<!-- \
 const MARK = '\u0001NOTE:';
 const FRONT = /^---\r?\n[\s\S]*?\r?\n---\r?\n?/;
 
-const stripFront = (md) => String(md || '').replace(FRONT, '').replace(/\r\n/g, '\n');
+// the slides' data block (Run 6) is for the slides only: no reader of the text sees it
+const SLIDES_DATA = /\n?<!-- pmos:slides v1 \{[^\n]*\} -->\s*$/;
+const stripFront = (md) => String(md || '').replace(FRONT, '').replace(/\r\n/g, '\n').replace(SLIDES_DATA, '\n');
 const cells = (ln) => ln.trim().replace(/^\|/, '').replace(/\|$/, '').split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, '|'));
 const isRule = (ln) => /^\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(ln.trim());
 const bare = (h) => String(h || '').replace(/\s*\([a-z0-9._-]+\)\s*$/, '');
@@ -40,6 +44,7 @@ const bare = (h) => String(h || '').replace(/\s*\([a-z0-9._-]+\)\s*$/, '');
 function noteTitle(id, heading) {
   if (id === 'report.headline') return COPY.noteHeadline;
   if (id === 'report.asks') return COPY.noteAsks;
+  if (id === 'report.changelog') return COPY.noteChangelog;
   return COPY.noteOf(heading || id);
 }
 
@@ -151,6 +156,7 @@ export function clearPrint() { for (const n of document.querySelectorAll('body >
  * of the body and shows only it. It is removed when the print dialog closes, and again before the next print.
  */
 export function printReport(md) {
+  if (slidesBlock(md)) { printSlides(md); return; }   // a report with slides prints as slides, one per page (Run 6)
   ensureComponentsCss();
   ensurePrintCss();
   clearPrint();

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

@@ -61,6 +61,7 @@ export const COPY = {
   notesSub: 'A note is your text between the markers. Saving a note draws the report again from the files as they are now.',
   noteHeadline: 'Headline note',
   noteAsks: 'Note for needs your call',
+  noteChangelog: 'Note for the changelog slide',
   noteOf: (title) => 'Note on ' + title,
   noteSave: 'Save notes',
   noteSaved: 'Notes saved.',
@@ -103,6 +104,8 @@ export const COPY = {
   firesOnlyRunning: 'A schedule fires only while the workspace server runs.',
 
   flagTitle: 'The issues ledger has a line that is not read',
+
+  present: 'Present',
 };
 
 export const GLOSSARY = {

package/workspace/public/pm/roadmap.js

@@ -27,6 +27,7 @@ import { loadSortable, baseOptions, dragSet } from './bd-drag.js';
 import { COPY, shortDate } from './initiatives-copy.js';
 import { getRoadmap, sigKey, place, placed, leaveNow } from './initiatives-api.js';
 import { healthSignal, say, checkBySheet, onContextMenu } from './initiatives-ui.js';
+import { openDoc } from './panel-initiatives.js';
 
 const HORIZONS = ['now', 'next', 'later'];
 
@@ -37,6 +38,7 @@ export function mountRoadmap(host, env) {
   let data = null;
   let error = null;
   let showDormant = false;
+  let showUnrecorded = false;
   let dragging = false;
   let deferred = null;
   let focusId = null;
@@ -150,6 +152,18 @@ export function mountRoadmap(host, env) {
     });
   }
 
+  // A unit with documents and no record (routes-initiatives.js unrecordedOf). It opens its PRD, or its first document; it
+  // has no menu and no grip, because only a record can be placed.
+  function unrecordedCard(u) {
+    const doc = u.artifacts.find((a) => a.role === 'PRD') || u.artifacts[0];
+    const roles = [...new Set(u.artifacts.map((a) => a.role).filter(Boolean))];
+    return card({
+      title: u.title, meta: [COPY.noRecord, ...(roles.length ? [roles.join(' · ')] : [])],
+      onOpen: () => openDoc(null, doc.path, doc.role || 'DOC'), openLabel: COPY.aria.open(u.title),
+      muted: true, attrs: { class: 'in-card', 'data-in-unrecorded-card': u.id }, openAttrs: { 'data-in-unrecorded-open': u.id },
+    });
+  }
+
   function column(h) {
     const rows = data.horizons[h] || [];
     const list = el('div', { class: 'in-list', 'data-in-list': h, role: 'list', 'aria-label': COPY.aria.column(COPY.horizons[h]) }, rows.map((r) => cardOf(r, { grip: true })));
@@ -166,6 +180,15 @@ export function mountRoadmap(host, env) {
       }));
       if (showDormant) kids.push(el('div', { class: 'in-list in-list--dormant', 'data-in-dormant': '' }, data.dormant.map((r) => cardOf(r, { grip: false }))));
     }
+    if (h === 'later' && data.unrecorded && data.unrecorded.length) {
+      const n = data.unrecorded.length;
+      kids.push(button({
+        label: showUnrecorded ? COPY.hideUnrecorded(n) : COPY.unrecorded(n), variant: 'ghost', size: 'sm',
+        icon: showUnrecorded ? 'chevron-down' : 'chevron-right', attrs: { 'data-in-unrecorded-toggle': '', 'aria-expanded': showUnrecorded ? 'true' : 'false' },
+        onClick: () => { showUnrecorded = !showUnrecorded; render(); },
+      }));
+      if (showUnrecorded) kids.push(el('div', { class: 'in-list in-list--dormant', 'data-in-unrecorded': '' }, data.unrecorded.map(unrecordedCard)));
+    }
     return el('section', { class: 'in-col', 'data-in-col': h, 'aria-label': COPY.horizons[h] }, kids);
   }
 

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

@@ -0,0 +1,52 @@
+/* pm/slides-copy.js — every word on the biweekly slides and their deck (pm-os-absorb Run 6; PRD R22.7).
+ *
+ * Pure data and pure functions. No DOM and no import, so glossary.test.js loads this file in Node and checks each string
+ * against the glossary rules. report-slides.js draws the slides from these strings and nothing else.
+ *
+ * The slides copy the PM-OS biweekly deck word for word: the PM asked for the slide format "exactly" as PM-OS has it
+ * (2026-10-06). So GLOSSARY.exempt lifts two rules for this file only: the column and slide names "Release" and "Release
+ * notes", and the empty column "Nothing shipped.", are the PM-OS deck's own words. Everywhere else in the workspace the
+ * rules hold. A slide is still ISSUED with its report, never sent (D71): the issued-not-sent rule applies here too.
+ */
+
+export const COPY = {
+  slidesTitle: 'Slides',
+  slidesMissing: 'This report has no slides. Redraft it to get them.',
+  slidesPrev: 'Previous slide',
+  slidesNext: 'Next slide',
+  slidesClose: 'Close the slides',
+  slidesCount: (n, of) => n + ' / ' + of,
+  print: 'Print / PDF',
+  more: (n) => '+' + n + ' more',
+  roadmap: 'Roadmap',
+  list: 'Initiative progress',
+  changelog: 'Release notes',
+  issues: 'Issues',
+  duration: 'Duration',
+  initiative: 'Initiative',
+  status: 'Status',
+  nextMilestone: 'Next milestone',
+  release: 'Release',
+  overdue: (d) => 'Overdue · ' + d,
+  noBreakdown: 'No breakdown',
+  noInitiatives: 'No initiatives in this window.',
+  lastCycle: 'Last cycle',
+  nextCycle: 'Next cycle',
+  milestone: 'Milestone',
+  nothingShipped: 'Nothing shipped.',
+  nothingPlanned: 'Nothing planned.',
+  noteType: { note: 'Note', info: 'Info', warning: 'Warning' },
+  noReleaseNotes: 'No release notes logged.',
+  entries: (n) => n + (n === 1 ? ' entry' : ' entries'),
+};
+
+export const GLOSSARY = {
+  exempt: {
+    release: 'The PM-OS deck names its column "Release" and its slide "Release notes"; the PM asked for that format exactly (2026-10-06).',
+    claims: 'The PM-OS deck says "Nothing shipped." in an empty Last cycle; the PM asked for that format exactly (2026-10-06).',
+  },
+  extra: [
+    { id: 'issued-not-sent', re: /\b(?:sent|sends?|sending|e-?mail(?:s|ed|ing)?|shar(?:e|es|ed|ing)|post(?:s|ed|ing)? to)\b/i, why: 'A report is issued, never sent (D71). The slides have no control that moves a report out of the workspace.' },
+  ],
+  guide: 'report-slides.md',
+};

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

@@ -56,6 +56,35 @@ export const COPY = {
   commandShown: (cmd) => `Run this in a terminal: ${cmd}`,
   noInitiative: 'This card names no initiative.',
   sessionGone: 'That session has ended.',
+  /** The goals for today (initiative today-goals, PRD G6). The word for what the session finds is "step", never a plan. */
+  goals: {
+    title: 'Goals for today',
+    toggle: (open, total) => (total ? `Goals for today · ${open} open of ${total}` : 'Set your goals for today'),
+    intro: 'List what you want done today. Prepare my day then finds the meetings, mentions and steps that move each goal.',
+    inputLabel: 'Add a goal',
+    inputHint: 'What do you want done today? Press Enter to add it.',
+    full: (max) => `A day has at most ${max} goals. Drop or remove one to add another.`,
+    prepareDay: 'Prepare my day',
+    prepareDayHint: 'Starts a session that reads your calendar and your Slack, Jira and Confluence mentions, and ties what it finds to your goals.',
+    started: 'The session started. The steps show here when it is done.',
+    coverage: { planned: 'has steps', 'needs-plan': 'no step yet', done: 'done', dropped: 'dropped' },
+    done: 'Done', drop: 'Drop', reopen: 'Reopen', remove: 'Remove',
+    you: 'You', agent: 'Agent', mention: 'mention',
+    noStep: 'No step found yet. Press Prepare my day, or open the initiative.',
+    prepare: 'Prepare',
+    queue: 'Queue it',
+    prepareShows: (key, branch) => `${key} on ${branch || 'a local branch'}. Queue it to approve this exact prompt.`,
+    queued: (key) => `Queued ${key}. It starts when background prepare is on and the budget and quiet hours allow.`,
+    also: 'Also on your plate',
+    worthAsking: 'Worth asking',
+    free: (min, until) => `${Math.floor(min / 60)} h ${min % 60} min free until ${until}.`,
+    comingUp: (title, at) => `Coming up: ${title} at ${at}.`,
+    notRead: (list) => `Not read: ${list}.`,
+    stale: (date) => `What was read is from ${date}. It is out of date, so only what Today found is used.`,
+    noBrief: 'Nothing was read yet today. Press Prepare my day to read your calendar and mentions.',
+    refused: (why) => `Nothing changed. ${why}`,
+    unreached: 'The workspace did not answer.',
+  },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {
     review: 'Review',