create-pmos 0.530.0 → 0.532.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.530.0",
+  "version": "0.532.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {
@@ -32,6 +32,32 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.532.0",
+      "at": "2026-11-04T19:01:35.763Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1248,
+          "t": "Report templates T02–T08",
+          "s": "Report templates T02–T08",
+          "k": "new"
+        }
+      ]
+    },
+    {
+      "v": "0.531.0",
+      "at": "2026-11-04T18:44:50.726Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1247,
+          "t": "Report library frame and 23 slide layouts",
+          "s": "Report library frame and 23 slide layouts",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.530.0",
       "at": "2026-11-04T14:38:26.528Z",
@@ -393,46 +419,6 @@
           "k": "new"
         }
       ]
-    },
-    {
-      "v": "0.512.0",
-      "at": "2026-11-03T15:33:10.629Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1204,
-          "t": "Suggest the next prompt and sharpen a rough one in the chat",
-          "s": "Suggest the next prompt and sharpen a rough one in the chat",
-          "k": "new"
-        }
-      ]
-    },
-    {
-      "v": "0.511.0",
-      "at": "2026-11-03T15:10:29.930Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1202,
-          "t": "A closed initiative is never late on the Board",
-          "s": "A closed initiative is never late on the Board",
-          "k": "fix"
-        },
-        {
-          "n": 1200,
-          "t": "Open the chat on the Board, and dock panels left or right",
-          "s": "Open the chat on the Board, and dock panels left or right",
-          "k": "new"
-        },
-        {
-          "n": 1201,
-          "t": "Settings Updates tells each change as Claude's plain-language story (design E)",
-          "s": "Settings Updates tells each change as Claude's plain-language story (design E)",
-          "k": "new",
-          "h": "Updates read like a story",
-          "d": "Updates listed pull request titles and numbers, grouped by kind, which was hard to skim. Updates opens with a short summary of the week, then the newest version, then each change as a plain story, with a dot for New and Fixed."
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@5a2765e8
+kernel-source: pmos@c8e1d796
 assembled: 2026-11-04
 mode: vendor

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 status: stable
 ---
 

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

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-11-04T14:38:23Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:01:32Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,30 @@
 [
+ {
+  "v": "0.532.0",
+  "at": "2026-11-04T19:01:35.763Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1248,
+    "t": "Report templates T02–T08",
+    "s": "Report templates T02–T08",
+    "k": "new"
+   }
+  ]
+ },
+ {
+  "v": "0.531.0",
+  "at": "2026-11-04T18:44:50.726Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1247,
+    "t": "Report library frame and 23 slide layouts",
+    "s": "Report library frame and 23 slide layouts",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.530.0",
   "at": "2026-11-04T14:38:26.528Z",

package/workspace/guide/reports.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Reports: draft and issue a cadence report"
 description: "How pmos report drafts a cadence report with every number, how the notes are kept when you draft again, and how you issue and freeze a report."
-timestamp: 2026-11-02
+timestamp: 2026-11-04
 ---
 
 # Reports: draft and issue a cadence report
@@ -90,6 +90,10 @@ pmos report issue biweekly 2026-10-16
 
 `pmos report finder` shows the report finder setting, or changes it.
 
+`pmos report library` writes one page with every slide layout of the report library, filled with placeholder words. Open it in a browser to see the layouts a report can use. Add `--out <file>` to choose the file.
+
+The library also has seven report templates: weekly-review, program-kickoff, meeting-recap, portfolio-snapshot, quarterly-review, decision-brief and incident-review. A template is a default order of slides, not a fixed structure. `pmos report library --template <id>` draws one template with placeholder words. `pmos report make <id> --template <id>` starts a report from it: the writer uses its order and adds or drops slides when the findings say so. A recurring report keeps the outline its readers agreed, so the template is used only for a report that has none.
+
 Every command accepts `--root <dir>` to name the repository. `draft` and `list` also accept `--json`.
 
 ## The window

package/workspace/lib/report-cli.js

@@ -37,10 +37,10 @@ const actorLib = require('./actor.js');
 const RS = require('./report-setups.js');
 const { parseArgs } = require('./schedule-cli');
 
-const COMMANDS = { report: ['make', 'read', 'find', 'write', 'check', 'rule', 'draft', 'issue', 'list', 'propose', 'definitions', 'setups', 'finder'] };
+const COMMANDS = { report: ['make', 'read', 'find', 'write', 'check', 'rule', 'draft', 'issue', 'list', 'propose', 'definitions', 'setups', 'finder', 'library'] };
 const USAGE = [
   'usage: pmos report make|read|find|write|check|rule — the report engine: brief, read, find, answer, render (any report, any shape)',
-  '  pmos report make <id> [--ask "<the question>"] [--readers "<who>"] [--source <kind:ref>,…] [--slot <date>]',
+  '  pmos report make <id> [--ask "<the question>"] [--readers "<who>"] [--source <kind:ref>,…] [--template <id>] [--slot <date>]',
   '      Steps 1 to 3: derive the brief (readers, question, window, sources; no section list), read every source PMOS reaches,',
   '      and find what changed. An ad hoc report needs --ask. Sources: pmos · pack:<state file of readings> · connector:<name> · document:<path>.',
   '  pmos report read <id> [--slot <date>] --from <file|->',
@@ -54,6 +54,9 @@ const USAGE = [
   '  pmos report check <id> [--slot <date>]       the checks of the last write: substance first, then form',
   '  pmos report rule <id> list | add <voice|wording|off|keep> "<text or part>" | remove <n>',
   '      What the readers taught this report: a voice or wording rule, or a part beyond the ask turned off or kept.',
+  'usage: pmos report library [--template <id>] [--out <file>] [--json] — the slide library: every layout in the report frame, with placeholder words',
+  '      Writes one HTML page (default: report-library.html in the current folder). Open it in a browser to check the look.',
+  '      --template draws one report template (its card, then each part); --json lists the templates and the layouts.',
   'usage: pmos report draft|issue|list — cadence reports (for example the biweekly)',
   '  pmos report draft <cadence> [<slot>] [--now <time>] [--redraft]',
   '      Write the draft for a slot (default: today) with every number. Refuses a slot that has a draft;',
@@ -74,9 +77,9 @@ const USAGE = [
   '  every command: [--json] [--root <dir>]. The cadence is the report skill id without "report-", for example biweekly.',
 ];
 const BOOL = new Set(['json', 'redraft', 'help']);
-const VALUE = new Set(['now', 'root', 'ask', 'readers', 'source', 'slot', 'from']);
-const ALLOWED = { make: ['json', 'now', 'root', 'ask', 'readers', 'source', 'slot'], read: ['json', 'now', 'root', 'slot', 'from', 'source'], find: ['json', 'now', 'root', 'slot', 'from'],
-  write: ['json', 'now', 'root', 'slot', 'from'], check: ['json', 'root', 'slot'], rule: ['json', 'root'], draft: ['json', 'redraft', 'now', 'root'], issue: ['root'], list: ['json', 'root'], propose: ['json', 'root'], definitions: ['json', 'root'], setups: ['json', 'root'], finder: ['json', 'root'] };
+const VALUE = new Set(['now', 'root', 'ask', 'readers', 'source', 'slot', 'from', 'out', 'template']);
+const ALLOWED = { make: ['json', 'now', 'root', 'ask', 'readers', 'source', 'slot', 'template'], read: ['json', 'now', 'root', 'slot', 'from', 'source'], find: ['json', 'now', 'root', 'slot', 'from'],
+  write: ['json', 'now', 'root', 'slot', 'from'], check: ['json', 'root', 'slot'], rule: ['json', 'root'], draft: ['json', 'redraft', 'now', 'root'], issue: ['root'], list: ['json', 'root'], propose: ['json', 'root'], definitions: ['json', 'root'], setups: ['json', 'root'], finder: ['json', 'root'], library: ['json', 'out', 'template'] };
 const CADENCE_RE = /^[a-z][a-z0-9-]{0,39}$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -145,6 +148,23 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     return 0;
   }
 
+  if (verb === 'library') {
+    // the slide library as one page: sanitized as a report render is, with the workspace face inlined so the file shows it anywhere
+    const out = path.resolve(cwd || process.cwd(), typeof flags.out === 'string' && flags.out ? flags.out : 'report-library.html');
+    const D = require('./report-design.js');
+    const LB = require('./report-library.js');
+    if (flags.template !== undefined && !LB.templateOf(String(flags.template))) return fail(`there is no report template ${flags.template}. The templates: ${LB.TEMPLATES.map((t) => t.id).join(', ')}`, 2);
+    if (json && flags.out === undefined && flags.template === undefined) {
+      say(JSON.stringify({ ok: true, layouts: require('./report-slides.js').LAYOUTS.filter((x) => x !== 'blocks'), templates: LB.TEMPLATES.map((t) => ({ id: t.id, name: t.name, use: t.use, readers: t.readers, cadence: t.cadence, outline: t.outline })) }));
+      return 0;
+    }
+    let face = '';
+    try { face = `<style>@font-face{font-family:"Plus Jakarta Sans";font-weight:200 800;src:url(data:font/woff2;base64,${fs.readFileSync(path.join(__dirname, '..', 'public', 'vendor', 'plus-jakarta-sans-var.woff2')).toString('base64')}) format("woff2")}body{margin:0;background:#888}.pmos-slide{margin:0 auto 12px}</style>`; } catch { face = ''; }
+    const html = D.sanitize(LB.libraryHtml(flags.template ? { template: String(flags.template) } : {}));
+    try { fs.writeFileSync(out, html.replace('<style>', face + '<style>')); } catch (e) { return fail(`could not write ${out}: ${String((e && e.message) || e).slice(0, 160)}`); }
+    if (json) say(JSON.stringify({ ok: true, path: out })); else say(`Wrote ${out}`);
+    return 0;
+  }
   if (['make', 'read', 'find', 'write', 'check', 'rule'].includes(verb)) return engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin, now });
   if (verb === 'definitions' || verb === 'setups' || verb === 'propose' || verb === 'finder') return reportWorkspace(verb, { pos, flags, root, json, say, fail, cwd, isTTY, env, stdin, now });
 
@@ -219,7 +239,7 @@ function engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin
     return 0;
   };
   if (verb === 'make') {
-    const m = RE.make(root, id, { slot: day, ask: flags.ask, readers: flags.readers, sources, now: clock });
+    const m = RE.make(root, id, { slot: day, ask: flags.ask, readers: flags.readers, sources, template: flags.template, now: clock });
     if (!m.ok) return fail(m.error);
     return summary(m);
   }

package/workspace/lib/report-engine.js

@@ -205,7 +205,7 @@ function issuedSlots(root, id) {
 /** The headings of a document the engine did not write: the agreed outline of an older issue. */
 const headingsOf = (md) => str(md).replace(/^---[\s\S]*?\n---\n?/, '').split('\n').filter((l) => /^## /.test(l)).map((l) => l.slice(3).trim()).filter(Boolean);
 
-function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {}) {
+function briefOf(root, id, { slot, ask, readers, sources, template, now = Date.now() } = {}) {
   if (!ID_RE.test(str(id))) return refuse(400, 'the report id is lower case letters, digits and dashes, at most 40, starting with a letter');
   const today = slot || dayOf(now);
   if (!isDate(today)) return refuse(400, 'the slot is a date, YYYY-MM-DD');
@@ -213,7 +213,7 @@ function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {
   const P = paths(abs, id, today);
   const from = [];
   const brief = { v: 1, id, slot: today, title: null, readers: null, question: null, questions: [], decision: null, window: null, sources: [], recurring: false,
-    cycle_days: null, agreed_outline: [], earlier_outline: [], last_issue: null, carried_asks: [], rules: [], voice: VOICE.slice(), from };
+    cycle_days: null, agreed_outline: [], earlier_outline: [], template: null, last_issue: null, carried_asks: [], rules: [], voice: VOICE.slice(), from };
 
   // the definition: readers, the question (its purpose), the sources, the cadence
   let def = null; let defText = '';
@@ -280,6 +280,12 @@ function briefOf(root, id, { slot, ask, readers, sources, now = Date.now() } = {
     }
     from.push(LP.md.rel);
   }
+  // a report template (lib/report-library.js) is a default order of slide layouts for a report with no agreed outline; the agreed one wins
+  if (template) {
+    const t = require('./report-library.js').templateOf(str(template));
+    if (!t) return refuse(400, `there is no report template ${template}. The templates: ${require('./report-library.js').TEMPLATES.map((x) => x.id).join(', ')}`);
+    if (!brief.agreed_outline.length) { from.push(`template:${t.id}`); brief.template = { id: t.id, name: t.name, outline: t.outline.map((o) => ({ part: o.part, layout: o.layout })) }; }
+  }
   brief.rules = rulesOf(abs, id);
   for (const r of brief.rules) if (r.kind === 'voice' || r.kind === 'wording') brief.voice.push(r.text);
   return { ok: true, brief };
@@ -456,6 +462,10 @@ function textsOf(report) {
   if (isObj(report.answer)) { add('answer', report.answer.text); (report.answer.supports || []).forEach((s, i) => add(`answer.supports[${i}]`, s)); }
   (report.sections || []).forEach((s, i) => {
     add(`sections[${i}].title`, s.title);
+    add(`sections[${i}].eyebrow`, s.eyebrow); add(`sections[${i}].sub`, s.sub);
+    // a section bound to a library layout (lib/report-slides.js): every text in its data and its insight is the writer's, so it is checked too
+    if (s.layout) { try { require('./report-slides.js').textsOfLayout(s.layout, s.data).forEach((t) => add(`sections[${i}].data`, t)); } catch { /* shapeError names it */ } }
+    textsOfInsight(s.insight).forEach((t) => add(`sections[${i}].insight`, t));
     (s.blocks || []).forEach((b, j) => {
       const w = `sections[${i}].blocks[${j}]`;
       add(w, b.text); (b.items || []).forEach((x) => add(w, x));
@@ -475,11 +485,20 @@ function shapeError(report) {
   if (report.answer.supports != null && (!Array.isArray(report.answer.supports) || report.answer.supports.length > 5 || report.answer.supports.some((s) => !isStr(s)))) return 'answer.supports is a list of at most 5 sentences';
   if (!Array.isArray(report.sections) || report.sections.length > LIMITS.sections) return `sections is a list of at most ${LIMITS.sections} (any titles, any order: the writer chooses)`;
   const seen = new Set();
-  for (const [i, s] of report.sections.entries()) {
+  for (let [i, s] of report.sections.entries()) {
     if (!isObj(s) || !isStr(s.title) || !s.title.trim() || /[\r\n]/.test(s.title)) return `sections[${i}] has a one-line title`;
     const id = str(s.id) || slugOf(s.title);
     if (seen.has(id)) return `two sections share the id ${id}`;
     seen.add(id);
+    if (s.layout != null) {
+      const RS = require('./report-slides.js');
+      if (!RS.LAYOUTS.includes(s.layout) || s.layout === 'blocks') return `sections[${i}].layout is one of ${RS.LAYOUTS.filter((x) => x !== 'blocks').join(', ')} (or leave it out and write blocks)`;
+      const e = RS.layoutError(s.layout, s.data);
+      if (e) return `sections[${i}] (${s.layout}): ${e}`;
+      if (s.blocks == null) s = { ...s, blocks: [] };
+    }
+    if (s.insight != null && (!isObj(s.insight) || (s.insight.points != null && (!Array.isArray(s.insight.points) || s.insight.points.length > 4 || s.insight.points.some((x) => !isObj(x) || !isStr(x.text)))))) return `sections[${i}].insight is { head, text, points: [{ tone, text }] (at most 4), note }`;
+    for (const k of ['eyebrow', 'sub']) if (s[k] != null && (!isStr(s[k]) || /[\r\n]/.test(s[k]) || s[k].length > LIMITS.title)) return `sections[${i}].${k} is one line`;
     if (!Array.isArray(s.blocks) || s.blocks.length > LIMITS.blocks) return `sections[${i}].blocks is a list of at most ${LIMITS.blocks}`;
     for (const [j, b] of s.blocks.entries()) {
       if (!isObj(b) || !BLOCK_KINDS.includes(b.kind)) return `sections[${i}].blocks[${j}].kind is one of ${BLOCK_KINDS.join(', ')}`;
@@ -613,7 +632,17 @@ function renderMarkdown(report, { brief = null, readings = null, now = Date.now(
   }
   for (const s of report.sections) {
     lines.push(`## ${r(s.title)}`, '');
-    for (const b of s.blocks) lines.push(blockMd(b, null, byId, brief), '');
+    if (s.layout && !(s.blocks || []).length) {
+      // a section bound to a library layout and no blocks: the document holds the layout's lines and its insight, sourced like a block
+      const RS = require('./report-slides.js');
+      const texts = RS.textsOfLayout(s.layout, s.data).concat(textsOfInsight(s.insight));
+      const ls = RS.linesOf(s.layout, RS.mapLayout(s.layout, s.data, r));
+      if (ls.length) lines.push(ls.map((l) => `- ${l}`).join('\n'), '');
+      if (isObj(s.insight) && (s.insight.head || s.insight.text)) lines.push(`**${r(str(s.insight.head)) || 'Insight'}.** ${r(str(s.insight.text))}`.trim(), '');
+      const src = sourceLine(texts.flatMap(tokensIn), byId, brief);
+      if (src) lines.push(`*${src}*`, '');
+    }
+    for (const b of s.blocks || []) lines.push(blockMd(b, null, byId, brief), '');
   }
   for (const p of beyondParts(report)) {
     lines.push(`## ${p.label}`, '');
@@ -644,50 +673,77 @@ function periodOf(brief, R) {
   const ats = R.map((x) => x.at).sort();
   return 'Data of ' + span(ats[0], ats[ats.length - 1]);
 }
-/** The deck of an engine report: the same model, drawn as slides (lib/report-pyramid.js deckHtml and lib/report-export.js pptx draw it). */
+/** The deck of an engine report: the same model, drawn as slides in the report library's frame (B2, lib/report-slides.js; batch 27 item 14).
+ *  Each slide keeps its kind (title, answer, section, beyond, ask, sources) and names its layout: the title is the overview with the sections as its
+ *  agenda, the answer lists its supports with the ask in the insight column, a section is drawn by the layout it names (else its blocks), the parts
+ *  beyond the question are a numbered list, the ask is the decisions layout and the sources close the deck. lib/report-pyramid.js deckHtml and
+ *  lib/report-export.js pptx draw it. */
 function deckOf(report, { brief = null, readings = null, look = null } = {}) {
+  const RS = require('./report-slides.js');
   const R = Array.isArray(readings && readings.readings) ? readings.readings : [];
   const byId = new Map(R.map((r) => [r.id, r]));
   const r = (t) => String(resolve(t, byId));
   const srcOf = (ids) => sourceLine(ids, byId, brief).replace(/\.$/, '');
   const slides = [];
+  const deckName = (brief && brief.title) || '';
   const titleText = clip(r(report.title), 160);
-  slides.push({ kind: 'title', tag: [brief && brief.title, brief && brief.readers ? `for ${brief.readers}` : ''].filter(Boolean).join(' · ') || 'Report', title: titleText, size: titleText.length > 60 ? 48 : 64,
-    sub: brief ? periodOf(brief, R) : '', source: srcOf(tokensIn(report.title)) });
-  const supports = (report.answer.supports || []).map((s) => { const t = r(s); const m = /^([^:]{3,80}):\s+(.+)$/.exec(t); return m ? { head: m[1], text: m[2] } : { head: t, text: '' }; });
-  const ask = report.ask ? { question: r(report.ask.text), who: report.ask.who ? r(report.ask.who) : (brief && brief.readers) || '', by: report.ask.by ? full(report.ask.by) : null, options: (report.ask.options || []).map(r), more: '' } : null;
-  slides.push({ kind: 'answer', tag: 'The answer', title: clip(r(report.answer.text), 200), lead: '', supports, ask,
+  const firstLine = (s) => { const ins = isObj(s.insight) ? str(s.insight.head) || str(s.insight.text) : ''; const p = (s.blocks || []).find((b) => b && b.kind === 'p'); return ins || str(s.sub) || (p ? str(p.text) : ''); };
+  const agenda = report.sections.slice(0, 4).map((s) => ({ head: clip(r(s.title), 80), text: clip(r(firstLine(s)), 110) }));
+  slides.push({ kind: 'title', layout: agenda.length ? 'overview' : 'statement', eyebrow: [brief && brief.title, brief && brief.readers ? `for ${brief.readers}` : ''].filter(Boolean).join(' · ') || 'Report',
+    title: titleText, sub: brief ? periodOf(brief, R) : '', data: agenda.length ? { lead: clip(r(report.answer.text), 200), cols: agenda } : { text: r(report.answer.text) }, source: srcOf(tokensIn(report.title).concat(tokensIn(report.answer.text))) });
+  const supports = (report.answer.supports || []).map((s) => { const t = r(s); const m = /^([^:]{3,80}):\s+(.+)$/.exec(t); return m ? { title: m[1], text: m[2].charAt(0).toUpperCase() + m[2].slice(1) } : { title: t, text: '' }; });
+  const ask = report.ask ? { question: r(report.ask.text), who: report.ask.who ? r(report.ask.who) : (brief && brief.readers) || '', by: report.ask.by || null, options: (report.ask.options || []).map(r) } : null;
+  const askInsight = ask ? { head: 'Your call', text: ask.question, points: [], note: [ask.who ? `For ${ask.who}` : '', ask.by ? `by ${full(ask.by)}` : ''].filter(Boolean).join(' · ') } : null;
+  slides.push({ kind: 'answer', layout: supports.length ? 'agenda' : 'statement', eyebrow: 'The answer', title: clip(r(report.answer.text), 200), sub: '',
+    data: supports.length ? { rows: supports.slice(0, 5) } : { text: r(report.answer.text) }, insight: askInsight,
     source: srcOf(tokensIn(report.answer.text).concat(...(report.answer.supports || []).map(tokensIn))) });
   for (const s of report.sections) {
+    if (s.layout && !RS.layoutError(s.layout, s.data)) {
+      // the writer bound this section to a library layout: its texts are resolved here, its insight goes in the side column
+      const data = RS.mapLayout(s.layout, s.data, r);
+      const ins = isObj(s.insight) ? { head: r(str(s.insight.head)), text: r(str(s.insight.text)), points: (Array.isArray(s.insight.points) ? s.insight.points : []).map((x) => ({ tone: x.tone, text: r(str(x.text)) })), note: r(str(s.insight.note)) } : null;
+      const ids = RS.textsOfLayout(s.layout, s.data).concat(textsOfInsight(s.insight)).flatMap(tokensIn);
+      slides.push({ kind: 'section', layout: s.layout, eyebrow: s.eyebrow ? r(s.eyebrow) : '', title: clip(r(s.title), 160), sub: s.sub ? r(s.sub) : '', data, insight: ins, source: srcOf(ids) });
+      continue;
+    }
     // a section goes on as many slides as its blocks need: a long table is cut at 8 rows, and a block that would run under the footer starts a new slide
     const chunks = [[]]; let used = 0;
     const put = (b) => { const h = blockHeight(b); if (chunks[chunks.length - 1].length && used + h > SLIDE_ROOM) { chunks.push([]); used = 0; } chunks[chunks.length - 1].push(b); used += h; };
-    for (const b of s.blocks) {
+    for (const b of s.blocks || []) {
       if (b.kind === 'table' && b.rows.length > 8) for (let i = 0; i < b.rows.length; i += 8) put({ ...b, rows: b.rows.slice(i, i + 8) });
       else put(b);
     }
     const real = chunks.filter((c) => c.length);
     real.forEach((blocks, i) => {
       const ids = blocks.flatMap((b) => textsOf({ title: '', answer: { text: '' }, sections: [{ title: '', blocks: [b] }] }).flatMap((t) => tokensIn(t.text)));
-      slides.push({ kind: 'section', title: clip(r(s.title), 160) + (i ? ' (continued)' : ''), blocks: blocks.map((b) => drawBlock(b, r, byId)), source: srcOf(ids) });
+      slides.push({ kind: 'section', layout: 'blocks', eyebrow: '', title: clip(r(s.title), 160) + (i ? ' (continued)' : ''), sub: '', data: { blocks: blocks.map((b) => drawBlock(b, r, byId)) }, blocks: blocks.map((b) => drawBlock(b, r, byId)), source: srcOf(ids) });
     });
   }
   const parts = beyondParts(report);
   for (let i = 0; i < parts.length; i += 4) {
     const chunk = parts.slice(i, i + 4);
     // the title is a finding, as on every slide: the first part's own sentence
-    slides.push({ kind: 'beyond', tag: 'Beyond the question', title: clip(r(chunk[0].texts[0]), 160), items: chunk.map((p) => ({ head: p.label, text: clip(p.texts.map(r).join(' '), 260) })),
+    slides.push({ kind: 'beyond', layout: 'agenda', eyebrow: 'Beyond the question', title: clip(r(chunk[0].texts[0]), 160), sub: '',
+      data: { rows: chunk.map((p) => ({ title: p.label, text: clip(p.texts.map(r).join(' '), 260) })) }, items: chunk.map((p) => ({ head: p.label, text: clip(p.texts.map(r).join(' '), 260) })),
       source: srcOf(chunk.flatMap((p) => p.texts.flatMap(tokensIn))) });
   }
-  if (ask && (ask.options.length || ask.who)) slides.push({ kind: 'ask', tag: 'Needs your call', title: clip(ask.by ? `Decide by ${ask.by}: ${ask.question.replace(/\?$/, '')}` : ask.question, 200), ask, source: 'Source: the readings above' });
+  if (ask && (ask.options.length || ask.who)) {
+    const rows = ask.options.length ? ask.options.slice(0, 3).map((o, i) => ({ question: `Option ${'ABC'[i]}: ${o}`, who: ask.who, by: ask.by || undefined })) : [{ question: ask.question, who: ask.who, by: ask.by || undefined }];
+    slides.push({ kind: 'ask', layout: 'decisions', eyebrow: 'Needs your call', title: clip(ask.by ? `Decide by ${full(ask.by)}: ${ask.question.replace(/\?$/, '')}` : ask.question, 200), sub: ask.options.length ? ask.question : '',
+      data: { rows }, source: 'Source: the readings above' });
+  }
   const names = new Map(((brief && brief.sources) || []).map((x) => [x.id, x.name]));
   const used = new Set(textsOf(report).flatMap((t) => tokensIn(t.text)));
-  const reached = [...new Set(R.filter((x) => used.has(x.id)).map((x) => x.source))].map((s) => `${names.get(s) || s}, read ${[...new Set(R.filter((x) => x.source === s && used.has(x.id)).map((x) => x.at))].sort().map(full).join(', ')}`);
-  const nr = (Array.isArray(readings && readings.gaps) ? readings.gaps : []).map((g) => ({ source: names.get(g.source) || g.source, why: g.reason }));
-  slides.push({ kind: 'sources', title: `Every number comes from ${reached.length === 1 ? 'one source' : `${reached.length} sources`}${nr.length ? `; ${nr.length === 1 ? 'one source was' : `${nr.length} sources were`} not reached` : ''}`, reached, notReached: nr, source: 'Source: the readings of this report' });
+  const srcIds = [...new Set(R.filter((x) => used.has(x.id)).map((x) => x.source))];
+  const lastAt = (s) => R.filter((x) => x.source === s && used.has(x.id)).map((x) => x.at).filter((a) => /^\d{4}-\d{2}-\d{2}$/.test(str(a))).sort().pop();
+  const read = srcIds.map((s) => ({ name: names.get(s) || s, ...(lastAt(s) ? { at: lastAt(s) } : {}) }));
+  const nr = (Array.isArray(readings && readings.gaps) ? readings.gaps : []).map((g) => ({ name: names.get(g.source) || g.source, why: str(g.reason) }));
+  slides.push({ kind: 'sources', layout: 'sources', eyebrow: 'Sources', title: `${read.length ? `Every number comes from ${read.length === 1 ? 'one source' : `${read.length} sources`}` : 'No reading is used on these slides'}${nr.length ? `; ${nr.length === 1 ? 'one source was' : `${nr.length} sources were`} not reached` : ''}`, sub: '',
+    data: { read: read.slice(0, 6), missing: nr.slice(0, 6) }, reached: read.map((x) => x.name + (x.at ? ', read ' + full(x.at) : '')), notReached: nr.map((x) => ({ source: x.name, why: x.why })), source: 'Source: the readings of this report' });
   slides.forEach((s, i) => { s.n = i + 1; });
-  return { slides, look: look || null, name: r(report.title), engine: true };
+  return { slides, look: look || null, name: r(report.title), deck: deckName, today: (brief && brief.slot) || null, engine: true, frame: 'b2' };
 }
+function textsOfInsight(ins) { return isObj(ins) ? [ins.head, ins.text, ins.note].concat((Array.isArray(ins.points) ? ins.points : []).map((x) => x && x.text)).filter(isStr) : []; }
 /** The room under a slide's title, and what a block takes of it (1280 x 720 frames, lib/report-pyramid.js css). */
 const SLIDE_ROOM = 440;
 function blockHeight(b) {
@@ -713,7 +769,7 @@ function drawBlock(b, r, byId) {
 // ── the steps, written ──────────────────────────────────────────────────────────────────────────────────────────────
 function isIssued(root, id, slot) { return issuedSlots(root, id).includes(slot); }
 /** Steps 1–3: the brief, the readings, the findings, written next to the draft. Filed readings and findings are kept across a re-read. */
-function make(root, id, { slot, ask, readers, sources, add, gaps, addFindings, now = Date.now() } = {}) {
+function make(root, id, { slot, ask, readers, sources, template, add, gaps, addFindings, now = Date.now() } = {}) {
   const abs = path.resolve(String(root));
   const day = slot || dayOf(now);
   let P; try { P = paths(abs, id, day); } catch (e) { return refuse(400, e.message); }
@@ -721,6 +777,7 @@ function make(root, id, { slot, ask, readers, sources, add, gaps, addFindings, n
   const old = readJson(P.brief.abs);
   // a re-read keeps the brief's chat question and named sources unless new ones are given
   const b = briefOf(abs, id, { slot: day, now, ask: ask || (old && old.from && old.from.includes('chat') ? old.question : undefined), readers: readers || (old && old.from && old.from.includes('readers') ? old.readers : undefined),
+    template: template || (old && old.template ? old.template.id : undefined),
     sources: [...(old ? old.sources.filter((s) => s.kind === 'pack' || s.kind === 'connector' || s.kind === 'document') : []), ...(sources || [])] });
   if (!b.ok) return b;
   const rd = readingsOf(abs, b.brief, { add, gaps, keep: readJson(P.readings.abs), now });
@@ -748,7 +805,7 @@ function write(root, id, slot, report, { now = Date.now() } = {}) {
   const pre = checkReport(report, { brief, readings });
   const hardFail = pre.filter((c) => c.hard && !c.pass);
   if (hardFail.length) return refuse(422, hardFail.map((c) => `${c.id}: ${c.reason}`).join(' · '), { checks: pre });
-  const clean = { ...report, sections: report.sections.map((s) => ({ ...s, id: str(s.id) || slugOf(s.title) })), carried: brief.carried_asks || [], v: 1, at: new Date(now).toISOString() };
+  const clean = { ...report, sections: report.sections.map((s) => ({ ...s, blocks: Array.isArray(s.blocks) ? s.blocks : [], id: str(s.id) || slugOf(s.title) })), carried: brief.carried_asks || [], v: 1, at: new Date(now).toISOString() };
   const md = renderMarkdown(clean, { brief, readings, now });
   const checks = checkReport(clean, { brief, readings, markdown: md });
   writeJson(P.report.abs, clean);