create-pmos 0.52.0 → 0.53.1

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

@@ -0,0 +1,309 @@
+/* pm/report-view.js — a report as the PM reads it, and the acts on it (pm-os-absorb Run 5, slice 5C; PRD R9, R22.5, R25).
+ *
+ * One module for what Reports (dest-reports.js) and the Today cards share, so Issue works the same from either place:
+ *   parseReport(md)          the draft's markdown as blocks, split at the note markers (classes only, no inline style)
+ *   renderReport(md)         those blocks as DOM nodes; a note shows as its own text and nothing is built from a string
+ *   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
+ *   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
+ *
+ * Today cards (registerTodayCard): `report-issue` (kind 1) opens the Issue sheet; `schedule-no-output` (kind 8) is Draft now.
+ * The `cycle-kill-check` row (kind 7) is drawn by the initiatives run's card for kind 7, not here.
+ *
+ * Nothing on this page sends a report anywhere: the only things a report leaves through are the PM's own Print / PDF and
+ * Copy as markdown. No `by` is sent; the server takes the actor from the call path (D86 point 2).
+ */
+
+import { el } from './dom.js';
+import { button, field, sheet, toast, card, badge, ensureComponentsCss, SEL } from './primitives.js';
+import { ensureSprite } from './icons.js';
+import { pmGet, pmPost } from './http.js';
+import { registerTodayCard } from './registry.js';
+import { COPY } from './reports-copy.js';
+
+/* ── the markdown subset the drafter writes ───────────────────────────────────────────────────────────────────────── */
+
+const NOTE_RE = /<!-- pmos:note ([a-z0-9][a-z0-9._-]*) -->\n?([\s\S]*?)\n?<!-- \/pmos:note -->/g;
+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');
+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*$/, '');
+
+/** The title a note carries in the notes sheet: its headline or asks name, else the initiative heading above it. */
+function noteTitle(id, heading) {
+  if (id === 'report.headline') return COPY.noteHeadline;
+  if (id === 'report.asks') return COPY.noteAsks;
+  return COPY.noteOf(heading || id);
+}
+
+/** The draft as blocks: h1 h2 h3 p ul table note. A note keeps its text exactly; everything else is read line by line. */
+export function parseReport(md) {
+  const notes = new Map();
+  const body = stripFront(md).replace(NOTE_RE, (_all, id, text) => { notes.set(id, text); return '\n' + MARK + id + '\n'; });
+  const lines = body.split('\n');
+  const blocks = [];
+  let heading = '';
+  for (let i = 0; i < lines.length;) {
+    const ln = lines[i];
+    if (!ln.trim()) { i++; continue; }
+    if (ln.startsWith(MARK)) { const id = ln.slice(MARK.length); blocks.push({ t: 'note', id, text: notes.get(id) || '', title: noteTitle(id, heading) }); i++; continue; }
+    const h = /^(#{1,3})\s+(.*)$/.exec(ln);
+    if (h) { if (h[1].length === 3) heading = bare(h[2]); if (h[1].length === 2) heading = ''; blocks.push({ t: 'h' + h[1].length, text: h[2] }); i++; continue; }
+    if (ln.trim().startsWith('|')) {
+      const rows = [];
+      while (i < lines.length && lines[i].trim().startsWith('|')) { if (!isRule(lines[i])) rows.push(cells(lines[i])); i++; }
+      blocks.push({ t: 'table', head: rows[0] || [], rows: rows.slice(1) });
+      continue;
+    }
+    if (/^- /.test(ln)) {
+      const items = [];
+      while (i < lines.length && /^- /.test(lines[i])) { items.push(lines[i].slice(2)); i++; }
+      blocks.push({ t: 'ul', items });
+      continue;
+    }
+    const para = [];
+    while (i < lines.length && lines[i].trim() && !lines[i].startsWith(MARK) && !/^(#{1,3}\s|\|\s*|- )/.test(lines[i])) { para.push(lines[i].trim()); i++; }
+    blocks.push({ t: 'p', text: para.join(' ') });
+  }
+  return blocks;
+}
+
+/** The notes of the draft, in the order they appear. */
+export function noteSlots(md) {
+  return parseReport(md).filter((b) => b.t === 'note').map((b) => ({ id: b.id, title: b.title, text: b.text }));
+}
+
+/** "a **bold** run" as text and <strong> nodes. No HTML is built from a string. */
+function inline(text) {
+  const out = [];
+  String(text).split(/(\*\*[^*]+\*\*)/).forEach((part) => {
+    if (!part) return;
+    if (/^\*\*[^*]+\*\*$/.test(part)) out.push(el('strong', { class: 'rp-doc__strong' }, part.slice(2, -2)));
+    else out.push(part);
+  });
+  return out;
+}
+
+/** The draft as one `div.rp-doc`. A note with no text builds nothing: an empty note is a slot, not a line of the report. */
+export function renderReport(md) {
+  const root = el('div', { class: 'rp-doc' });
+  for (const b of parseReport(md)) {
+    if (b.t === 'h1') root.appendChild(el('h1', { class: 'rp-doc__h1' }, inline(b.text)));
+    else if (b.t === 'h2') root.appendChild(el('h2', { class: 'rp-doc__h2' }, inline(b.text)));
+    else if (b.t === 'h3') root.appendChild(el('h3', { class: 'rp-doc__h3' }, inline(b.text)));
+    else if (b.t === 'p') root.appendChild(el('p', { class: 'rp-doc__p' }, inline(b.text)));
+    else if (b.t === 'ul') root.appendChild(el('ul', { class: 'rp-doc__list' }, b.items.map((x) => el('li', { class: 'rp-doc__li' }, inline(x)))));
+    else if (b.t === 'table') {
+      root.appendChild(el('div', { class: 'rp-doc__scroll' }, el('table', { class: 'rp-doc__table' },
+        el('thead', null, el('tr', null, b.head.map((c) => el('th', { class: 'rp-doc__th', scope: 'col' }, c)))),
+        el('tbody', null, b.rows.map((r) => el('tr', null, r.map((c) => el('td', { class: 'rp-doc__td' }, c))))))));
+    } else if (b.t === 'note' && b.text.trim()) {
+      root.appendChild(el('div', { class: 'rp-doc__note', 'data-note': b.id }, b.text.split(/\n{2,}/).map((p) => el('p', { class: 'rp-doc__p rp-doc__p--note' }, p))));
+    }
+  }
+  return root;
+}
+
+/** The markdown a person copies: no frontmatter, no note markers, the notes' own text kept in place. */
+export function markdownToCopy(md) {
+  return stripFront(md).replace(/<!-- \/?pmos:note[^>]*-->\n?/g, '').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+}
+
+/* ── the two things a report leaves through: Copy as markdown, Print / PDF ───────────────────────────────────────── */
+
+export async function copyMarkdown(md) {
+  const text = markdownToCopy(md);
+  let done = false;
+  try { if (navigator.clipboard && navigator.clipboard.writeText) { await navigator.clipboard.writeText(text); done = true; } } catch { done = false; }
+  if (!done) {
+    // clipboard API refused (no permission, or a plain http page): the old route, from a text area that is removed at once
+    const area = document.createElement('textarea');
+    area.value = text; area.className = 'rp-copy-area'; area.setAttribute('aria-hidden', 'true'); area.setAttribute('tabindex', '-1');
+    document.body.appendChild(area); area.select();
+    try { done = document.execCommand('copy'); } catch { done = false; }
+    area.remove();
+  }
+  ensureComponentsCss();
+  toast({ text: done ? COPY.copied : COPY.copyFailed, tone: done ? undefined : 'error' });
+  return done;
+}
+
+/** Link /pm/print.css once, for print only. */
+export function ensurePrintCss() {
+  if (typeof document === 'undefined' || document.querySelector('link[data-rp-print]')) return;
+  const l = document.createElement('link');
+  l.rel = 'stylesheet'; l.href = '/pm/print.css'; l.media = 'print';
+  l.setAttribute('data-rp-print', '');
+  document.head.appendChild(l);
+}
+/** Remove the printed copy of a report, if one is in the page. */
+export function clearPrint() { for (const n of document.querySelectorAll('body > .rp-print')) n.remove(); }
+
+/**
+ * The report on paper. `body > .rp-print` holds the rendered report in the light theme; print.css hides every other child
+ * 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) {
+  ensureComponentsCss();
+  ensurePrintCss();
+  clearPrint();
+  const host = el('div', { class: 'rp-print', 'data-pm-theme': 'light', 'aria-hidden': 'true' }, renderReport(md));
+  document.body.appendChild(host);
+  const drop = () => { host.remove(); window.removeEventListener('afterprint', drop); };
+  window.addEventListener('afterprint', drop);
+  try { window.print(); } catch { drop(); }
+}
+
+/* ── writes ───────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** Tell the page's other readers (Today's provider cards) that this repository's ledgers changed. */
+function changed(ws) {
+  try { window.dispatchEvent(new CustomEvent('pmos:ledgers', { detail: { changed: [ws] } })); } catch { /* no listener */ }
+}
+
+/** Draft now: write the next draft of `cadence`. `redraft` keeps every note. Resolves to the server's answer. */
+export async function draftNow({ ws, cadence, slot, redraft }) {
+  ensureComponentsCss();
+  const body = { ws, cadence };
+  if (slot) body.slot = slot;
+  if (redraft) body.redraft = true;
+  const r = await pmPost('/api/report/draft', body);
+  if (r && r.ok) { changed(ws); toast({ text: redraft ? COPY.redrafted : COPY.drafted(cadence, r.slot), timeout: 4000 }); }
+  else toast({ text: COPY.draftFailed + (r && r.error ? ' ' + r.error : ''), tone: 'error', timeout: 8000 });
+  return r;
+}
+
+/* ── the Issue sheet: two taps from anywhere ─────────────────────────────────────────────────────────────────────── */
+
+function headlineOf(md) {
+  const bl = parseReport(md);
+  const i = bl.findIndex((b) => b.t === 'h2' && /^headline$/i.test(b.text.trim()));
+  return i >= 0 && bl[i + 1] && bl[i + 1].t === 'p' ? bl[i + 1].text : '';
+}
+
+/**
+ * openIssueSheet({ ws, cadence, slot, onDone? })
+ * Tap 1 opened this sheet. It reads the draft and its sha. Tap 2 (Issue) posts { ws, cadence, slot, sha } to the PM-only
+ * route; a draft that changed since the read answers 409 and nothing is issued. After Issue the sheet offers Print / PDF
+ * and Copy as markdown, the only two ways a report leaves the page.
+ */
+export function openIssueSheet({ ws, cadence, slot, onDone } = {}) {
+  ensureComponentsCss();
+  ensureSprite();
+  if (!ws) { toast({ text: COPY.issueNoWs, tone: 'error' }); return null; }
+  const msg = el('p', { class: 'rp-sheet__msg', role: 'status' }, COPY.issueReading);
+  const head = el('p', { class: 'rp-sheet__headline' });
+  const acts = el('div', { class: 'rp-sheet__row' });
+  const cancel = button({ label: COPY.issueCancel, variant: 'ghost', onClick: () => sh.close() });
+  const sh = sheet({ title: COPY.issueTitle, sub: COPY.issueSub(cadence, slot), body: [msg, head, acts], actions: [cancel], attrs: { class: 'rp-sheet' } });
+  const actions = sh.dialog.querySelector(SEL.sheetActions);
+  let doc = null;
+  const close = button({ label: COPY.issueClose, variant: 'ghost', onClick: () => sh.close() });
+
+  const showError = (text) => { msg.textContent = text; msg.classList.add('rp-sheet__msg--bad'); actions.replaceChildren(close); };
+
+  const confirm = button({ label: COPY.issueConfirm, variant: 'primary', attrs: { 'data-rp-act': 'issue-confirm' }, onClick: async () => {
+    if (!doc) return;
+    confirm.disabled = true;
+    const r = await pmPost('/api/report/issue', { ws, cadence, slot, sha: doc.sha });
+    if (r && r.ok) {
+      changed(ws);
+      msg.classList.remove('rp-sheet__msg--bad');
+      msg.textContent = COPY.issueDone;
+      acts.replaceChildren(
+        button({ label: COPY.print, variant: 'outline', attrs: { 'data-rp-act': 'print' }, onClick: () => printReport(doc.markdown) }),
+        button({ label: COPY.copyMd, variant: 'outline', attrs: { 'data-rp-act': 'copy' }, onClick: () => copyMarkdown(doc.markdown) }));
+      actions.replaceChildren(button({ label: COPY.issueClose, variant: 'primary', onClick: () => sh.close() }));
+      if (onDone) { try { onDone(r); } catch (e) { console.error('[reports] onDone failed:', e); } }
+    } else {
+      confirm.disabled = false;
+      showError(r && r.status === 409 ? COPY.issueStale : COPY.issueFailed + (r && r.error ? ' ' + r.error : ''));
+    }
+  } });
+
+  pmGet('/api/report/draft?ws=' + encodeURIComponent(ws) + '&cadence=' + encodeURIComponent(cadence) + '&slot=' + encodeURIComponent(slot)).then((r) => {
+    if (!sh.open) return;
+    if (!r || r.ok === false || !r.exists) { showError(COPY.issueFailed + (r && r.error ? ' ' + r.error : '')); return; }
+    doc = r;
+    if (r.issued) { msg.textContent = COPY.frozen; actions.replaceChildren(close); return; }
+    msg.textContent = COPY.issueBody;
+    head.textContent = headlineOf(r.markdown);
+    actions.replaceChildren(confirm, cancel);
+    confirm.focus();
+  });
+  return sh;
+}
+
+/* ── the Notes sheet: every note in one place ─────────────────────────────────────────────────────────────────────── */
+
+/** openNotesSheet({ ws, cadence, slot, markdown, onSaved? }): a text area for each note marker of the draft. */
+export function openNotesSheet({ ws, cadence, slot, markdown, onSaved } = {}) {
+  ensureComponentsCss();
+  ensureSprite();
+  const slots = noteSlots(markdown);
+  const fields = slots.map((s) => ({ slot: s, f: field({ kind: 'textarea', label: s.title, value: s.text, attrs: { 'data-note-field': s.id } }) }));
+  const msg = el('p', { class: 'rp-sheet__msg', role: 'status' }, slots.length ? '' : COPY.noteNone);
+  let sh = null;
+  const cancel = button({ label: COPY.issueCancel, variant: 'ghost', onClick: () => sh.close() });
+  const save = button({ label: COPY.noteSave, variant: 'primary', attrs: { 'data-rp-act': 'notes-save' }, onClick: async () => {
+    save.disabled = true;
+    let failed = null;
+    for (const { slot: s, f } of fields) {
+      if (f.control.value === s.text) continue;       // only a note that changed is written
+      const r = await pmPost('/api/report/note', { ws, cadence, slot, id: s.id, text: f.control.value });
+      if (!r || !r.ok) { failed = r || {}; break; }
+      s.text = f.control.value;
+    }
+    save.disabled = false;
+    if (failed) { msg.textContent = COPY.noteFailed + (failed.error ? ' ' + failed.error : ''); msg.classList.add('rp-sheet__msg--bad'); return; }
+    changed(ws);
+    sh.close();
+    toast({ text: COPY.noteSaved, timeout: 3000 });
+    if (onSaved) onSaved();
+  } });
+  sh = sheet({ title: COPY.notesTitle, sub: COPY.notesSub, body: [msg, ...fields.map((x) => x.f)], actions: slots.length ? [save, cancel] : [cancel], attrs: { class: 'rp-sheet' } });
+  return sh;
+}
+
+/* ── the Today cards ──────────────────────────────────────────────────────────────────────────────────────────────── */
+
+/** run_id is "report-needs:<issue|no-output>:<cadence>:<slot or day>" (lib/report-needs.js). */
+function idsOf(row) {
+  const p = String((row && row.run_id) || '').split(':');
+  return { cadence: p[2] || '', slot: p[3] || '' };
+}
+
+registerTodayCard('report-issue', (row, ctx) => {
+  const { cadence, slot } = idsOf(row);
+  const t = row.today || {};
+  ensureComponentsCss();
+  return card({
+    title: row.question,
+    meta: [t.cause || COPY.todayIssueCause, t.evidence],
+    trail: [badge({ text: COPY.todayIssueTag, tone: 'outline' })],
+    openLabel: COPY.todayIssueOpen(cadence, slot),
+    onOpen: () => openIssueSheet({ ws: ctx.ws, cadence, slot }),
+    attrs: { 'data-today-row': 'report-issue', 'data-provider': 'report-needs', 'data-report': cadence + ':' + slot },
+  });
+});
+
+registerTodayCard('schedule-no-output', (row, ctx) => {
+  const { cadence } = idsOf(row);
+  const t = row.today || {};
+  ensureComponentsCss();
+  return card({
+    title: row.question,
+    meta: [t.cause || COPY.todayNoOutputCause, t.evidence],
+    trail: [badge({ text: COPY.todayDraftTag, tone: 'outline' })],
+    openLabel: COPY.todayDraftOpen(cadence),
+    onOpen: () => draftNow({ ws: ctx.ws, cadence }),
+    attrs: { 'data-today-row': 'schedule-no-output', 'data-provider': 'report-needs', 'data-report': cadence },
+  });
+});

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

@@ -0,0 +1,114 @@
+/* pm/reports-copy.js — every word the Reports destination shows (pm-os-absorb Run 5, slice 5C).
+ *
+ * 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. A string a person reads on Reports, in its sheets, on a report Today card or in a toast is
+ * written here and nowhere else. Instructional register (PMOS-STE): short sentences, one verb, the action first.
+ *
+ * A report is ISSUED, never sent (D71): the page has no control that moves a report out of the workspace, and no
+ * string here says it does. GLOSSARY.extra holds the rule that keeps the words out.
+ */
+
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/** "2026-10-16" -> "16 Oct". A date-only value is a calendar day, never shifted by the time zone. */
+export function shortDate(ymd) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(ymd || ''));
+  return m ? Number(m[3]) + ' ' + MON[Number(m[2]) - 1] : '';
+}
+/** An ISO timestamp -> "5 Oct", in the viewer's own calendar. */
+export function dayOf(iso) {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? '' : d.getDate() + ' ' + MON[d.getMonth()];
+}
+/** "biweekly" -> "Biweekly"; the cadence ids are the report ids. */
+export const cadenceName = (c) => { const s = String(c || ''); return s ? s[0].toUpperCase() + s.slice(1) : ''; };
+export const plural = (n, one, many) => (n === 1 ? '1 ' + one : n + ' ' + (many || one + 's'));
+
+export const COPY = {
+  title: 'Reports',
+  list: 'Reports of this repository',
+  none: 'No report yet. Press Draft now to write the first one.',
+  noRepo: 'Choose a repository to see its reports.',
+  loading: 'Reading the reports.',
+  readError: 'The reports could not be read.',
+  fixture: 'Reports are read from a repository. This preview shows none.',
+  showOlder: (n) => 'Show older (' + n + ')',
+  showFewer: 'Show fewer',
+
+  draftNow: 'Draft now',
+  redraft: 'Redraft',
+  issue: 'Issue',
+  editNotes: 'Edit notes',
+  more: 'More report actions',
+  print: 'Print / PDF',
+  copyMd: 'Copy as markdown',
+  copied: 'Copied as markdown.',
+  copyFailed: 'The browser refused the copy. Select the text and copy it by hand.',
+
+  reportName: (cadence, slot) => cadenceName(cadence) + ' report, ' + shortDate(slot),
+  rowTitle: (cadence, slot) => cadenceName(cadence) + ' · ' + shortDate(slot),
+  draft: 'Draft',
+  issued: (at, by) => 'Issued ' + (dayOf(at) || '') + (by ? ' by ' + by : ''),
+  edited: 'Edited after issue',
+  editedWhy: 'This file changed after it was issued. The issued bytes are in the issues ledger.',
+  frozen: 'Issued. The file is frozen.',
+
+  drafted: (cadence, slot) => 'Drafted the ' + cadence + ' report for ' + shortDate(slot) + '.',
+  redrafted: 'Redrafted. Your notes are kept.',
+  draftFailed: 'The draft was not written.',
+
+  notesTitle: 'Notes',
+  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',
+  noteOf: (title) => 'Note on ' + title,
+  noteSave: 'Save notes',
+  noteSaved: 'Notes saved.',
+  noteFailed: 'The notes were not saved.',
+  noteNone: 'This draft has no note markers. There is no note to edit.',
+
+  issueTitle: 'Issue this report',
+  issueBody: 'Issue freezes the report as you read it. The file does not change after this.',
+  issueSub: (cadence, slot) => cadenceName(cadence) + ' report, ' + shortDate(slot),
+  issueConfirm: 'Issue',
+  issueCancel: 'Cancel',
+  issueReading: 'Reading the draft.',
+  issueDone: 'Issued. The file is frozen.',
+  issueStale: 'The draft changed while you read it. Close this sheet, read it again, then press Issue.',
+  issueFailed: 'Nothing was issued.',
+  issueNoWs: 'No repository is open, so nothing was issued.',
+  issueClose: 'Close',
+
+  todayIssueCause: 'A draft is ready to issue',
+  todayNoOutputCause: 'A schedule ran and left no draft',
+  todayDraftOpen: (cadence) => 'Draft the ' + cadence + ' report',
+  todayIssueOpen: (cadence, slot) => 'Issue the ' + cadence + ' report of ' + shortDate(slot),
+  todayIssueTag: 'Issue',
+  todayDraftTag: 'Draft now',
+
+  schedulesTitle: 'Report schedules',
+  schedulesNone: 'No report schedule is set. A schedule drafts a report at its time; it never issues one.',
+  schedulesSeed: 'Set up report schedules',
+  schedulesSeeded: (n) => (n ? 'Set up ' + plural(n, 'report schedule') + '.' : 'The report schedules were already set up.'),
+  schedulesFailed: 'The schedules were not changed.',
+  pause: 'Pause',
+  resume: 'Resume',
+  paused: 'Paused',
+  pausedMsg: (name) => name + ' is paused.',
+  resumed: (name) => name + ' runs again.',
+  otherSchedules: (n) => 'Other schedules (' + n + ')',
+  scheduleMeta: (when, last) => when + (last ? ' · ' + last : ''),
+  lastRan: (iso) => 'ran ' + dayOf(iso),
+  neverRan: 'has not run',
+  firesOnlyRunning: 'A schedule fires only while the workspace server runs.',
+
+  flagTitle: 'The issues ledger has a line that is not read',
+};
+
+export const GLOSSARY = {
+  exempt: {},
+  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). Reports has no control that moves a report out of the workspace.' },
+  ],
+  guide: 'reports-page.md',
+};