create-pmos 0.531.0 → 0.533.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.531.0",
+  "version": "0.533.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.533.0",
+      "at": "2026-11-04T19:35:12.134Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1249,
+          "t": "Component slots on report slides",
+          "s": "Component slots on report slides",
+          "k": "new"
+        }
+      ]
+    },
+    {
+      "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",
@@ -393,32 +419,6 @@
           "k": "fix"
         }
       ]
-    },
-    {
-      "v": "0.513.0",
-      "at": "2026-11-03T15:46:14.696Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1203,
-          "t": "Typography roles with Plus Jakarta Sans, two weights, four sizes",
-          "s": "Typography roles with Plus Jakarta Sans, two weights, four sizes",
-          "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"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@add0a4c9
+kernel-source: pmos@2120ce89
 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-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:35:08Z"}
 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-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:35:08Z"}
 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-04T18:44:47Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:35:08Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,30 @@
 [
+ {
+  "v": "0.533.0",
+  "at": "2026-11-04T19:35:12.134Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1249,
+    "t": "Component slots on report slides",
+    "s": "Component slots on report slides",
+    "k": "new"
+   }
+  ]
+ },
+ {
+  "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",

package/workspace/guide/reports.md

@@ -92,6 +92,10 @@ pmos report issue biweekly 2026-10-16
 
 `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.
+
+A slide can also hold a PMOS component instead of a layout: today, the KR metric tile of the Insights page, as a line, bars, a meter or a number. PMOS draws it from the KR metric record when the report is written and keeps a dated snapshot with the report, so an old issue shows the figures of its day. The slide says when the snapshot was taken, and the PowerPoint file draws the same tile.
+
 Every command accepts `--root <dir>` to name the repository. `draft` and `list` also accept `--json`.
 
 ## The window

package/workspace/lib/report-cli.js

@@ -40,7 +40,7 @@ const { parseArgs } = require('./schedule-cli');
 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,8 +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 [--out <file>] — the slide library: every layout in the report frame, with placeholder words',
+  '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;',
@@ -76,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', 'out']);
-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'], library: ['json', 'out'] };
+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}$/;
 
@@ -151,9 +152,15 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     // 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(require('./report-library.js').libraryHtml());
+    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;
@@ -201,7 +208,7 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
 }
 
 /** The report engine's verbs (lib/report-engine.js). An agent session and the PM may run them; issuing stays the PM's (`pmos report issue`). */
-function engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin, now }) {
+async function engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin, now }) {
   const RE = require('./report-engine.js');
   const id = pos[0];
   if (!id || !RE.ID_RE.test(id)) { say(`usage: pmos report ${verb} <id> …   (the id is lower case letters, digits and dashes, for example scarlet-assessment)`); return 2; }
@@ -232,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);
   }
@@ -245,7 +252,16 @@ function engineVerb(verb, { pos, flags, root, json, say, fail, isTTY, env, stdin
   }
   if (verb === 'write') {
     const r = readFrom(); if (r.error) return fail(r.error, 2);
-    const w = RE.write(root, id, day, r.body, { actor: who, now: clock });
+    // component slots: PMOS reads each record and draws its component now, and the snapshot is kept with the report (lib/report-slots.js)
+    const snapshots = {};
+    const secs = r.body && Array.isArray(r.body.sections) ? r.body.sections : [];
+    for (const [i, s] of secs.entries()) {
+      if (!s || s.layout !== 'component' || !s.data || typeof s.data !== 'object') continue;
+      const sn = await require('./report-slots.js').snapshotOf(root, s.data, { now: clock || Date.now() });
+      if (!sn.ok) return fail(`sections[${i}] (component): ${sn.error}`);
+      snapshots[i] = sn.snapshot;
+    }
+    const w = RE.write(root, id, day, r.body, { actor: who, now: clock, snapshots });
     if (!w.ok) {
       if (json) { say(JSON.stringify({ ok: false, error: w.error, checks: w.checks || null, none: !!w.none })); return 1; }
       say(`✗ ${w.error}`);

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 };
@@ -697,7 +703,8 @@ function deckOf(report, { brief = null, readings = null, look = null } = {}) {
       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) });
+      const snap = s.layout === 'component' && isObj(data.snapshot) ? data.snapshot : null;
+      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: snap ? `Source: PMOS ${snap.kind === 'kr' ? 'KR metric record' : 'record'} ${snap.ref}, last reading ${full(snap.readAt)}` : 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
@@ -763,7 +770,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); }
@@ -771,6 +778,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 });
@@ -788,7 +796,7 @@ function make(root, id, { slot, ask, readers, sources, add, gaps, addFindings, n
 }
 
 /** Steps 4–6: the writer's report.json, checked, then the document rendered. A report with no answer, or a figure that is not a reading, is refused. */
-function write(root, id, slot, report, { now = Date.now() } = {}) {
+function write(root, id, slot, report, { now = Date.now(), snapshots = {} } = {}) {
   const abs = path.resolve(String(root));
   let P; try { P = paths(abs, id, slot); } catch (e) { return refuse(400, e.message); }
   if (isIssued(abs, id, slot)) return refuse(409, `${id} ${slot} is issued; it is frozen`);
@@ -798,7 +806,10 @@ 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, 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() };
+  // a component slot's snapshot comes from PMOS (opts.snapshots, by section index: the CLI reads the record and draws it), never from the writer
+  const snaps = isObj(snapshots) ? snapshots : {};
+  const slotOf = (s, i) => (s.layout === 'component' && isObj(s.data) ? { ...s, data: { ...Object.fromEntries(Object.entries(s.data).filter(([k]) => k !== 'snapshot')), ...(snaps[i] ? { snapshot: snaps[i] } : {}) } } : s);
+  const clean = { ...report, sections: report.sections.map((s, i) => ({ ...slotOf(s, i), 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);

package/workspace/lib/report-export.js

@@ -512,6 +512,22 @@ function b2Parts(s, { shape, text }) {
     for (const [a, b] of d.edges) { const p = pos.get(a); const q = pos.get(b); const x1 = p.x + nw; const y1 = p.y + nh / 2; const x2 = q.x; const y2 = q.y + nh / 2; shape(Math.min(x1, x2), Math.min(y1, y2), Math.abs(x2 - x1), Math.abs(y2 - y1), { geom: 'line', line: '#9FB8E0', lw: 2, flip: y2 < y1 }); }
     d.nodes.forEach((n) => { const p = pos.get(n.id); const t = tn(n.tone); const [bg, ink] = t === 'bad' ? PILLC.bad : t === 'watch' || t === 'late' ? PILLC.watch : ['#FFFFFF', C.ink]; shape(p.x, p.y, nw, nh, { geom: 'roundRect', adj: round(14, nw, nh), fill: bg, line: bg === '#FFFFFF' ? '#DCDDE0' : null });
       text(p.x + 8, p.y + 18, nw - 16, 20, n.label, o({ size: 15, bold: true, color: ink, align: 'ctr' })); });
+  } else if (L === 'component' && d.snapshot && d.snapshot.kind === 'kr') {
+    // PMOS's KR metric tile, from the snapshot kept with the report: the value, its readings as bars from zero, the target line, the date
+    const sn = d.snapshot; const bw = Math.min(W, 760); const bh = 300;
+    shape(X, y, bw, bh, { geom: 'roundRect', adj: round(18, bw, bh), fill: C.well });
+    text(X + 22, y + 18, bw - 200, 20, sn.title, o({ size: 13, bold: true, color: C.ink2 }));
+    if (sn.chip) pill(X + bw - 22 - Math.min(160, 18 + sn.chip.length * 7), y + 16, sn.tone, sn.chip);
+    text(X + 22, y + 42, bw - 44, 56, sn.valueText || String(sn.value), o({ size: 40, bold: true, color: C.ink }));
+    text(X + 22, y + 100, bw - 44, 18, ['on ' + RS.dmy(sn.readAt), sn.targetText].filter(Boolean).join(' · '), o({ size: 13, color: C.ink3 }));
+    const ser = (sn.series || []).slice(-24); const hi = Math.max(...ser.map((p) => p.v), sn.target != null ? sn.target : 0) || 1; const px = X + 22; const pw = bw - 44; const py = y + 130; const ph = 130;
+    const cw = pw / Math.max(1, ser.length);
+    ser.forEach((p, i) => { const h = Math.max(1, (Math.max(0, p.v) / hi) * ph); shape(px + i * cw + cw * 0.2, py + ph - h, cw * 0.6, h, { fill: i === ser.length - 1 ? C.ink : '#C9CBCF' }); });
+    shape(px, py + ph, pw, 1, { fill: C.hair });
+    if (sn.target != null && sn.target >= 0) shape(px, py + ph - (sn.target / hi) * ph, pw, 1, { line: C.ink3, lw: 1, dash: true, name: 'Target' });
+    if (ser.length) { text(px, py + ph + 6, 200, 16, RS.dmy(ser[0].at), o({ size: 11, color: C.ink3 })); text(px + pw - 200, py + ph + 6, 200, 16, RS.dmy(ser[ser.length - 1].at), o({ size: 11, color: C.ink3, align: 'r' })); }
+    const when = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})$/.exec(String(sn.at)); const label = `Snapshot ${when ? RS.dmy(when[1]) + ' ' + when[2] : sn.at} · KR metric record ${sn.ref}`;
+    pill(X, y + bh + 12, 'none', label, Math.min(W, 30 + label.length * 6.6));
   } else plain();
   if (ins) {
     shape(902, y, 1, BOT - y, { fill: C.hair, name: 'Insight rule' });

package/workspace/lib/report-library.js

@@ -4,7 +4,9 @@
  * look can be checked against the boards in a browser, and what the tests draw.
  *
  *   sampleDeck({ today }) → { name, today, slides }   (pure; today = YYYY-MM-DD, default 2026-11-04, the canvas's day)
- *   libraryHtml(o)        → the sample deck as one page (lib/report-slides.js deckHtml)
+ *   libraryHtml(o)        → the sample deck as one page (lib/report-slides.js deckHtml); o.template = one template's deck instead
+ *   TEMPLATES · templateOf(id) → the 7 report templates (boards T02–T08): a default order of layouts, never a fixed structure
+ *   templateDeck(id, o)   → that template with placeholder words: its card, then each part in its layout
  *
  * Placeholder words only: nothing here is a reading, so it never goes into a report.
  */
@@ -69,8 +71,64 @@ function sampleDeck({ today = '2026-11-04' } = {}) {
       { date: '2026-11-10', time: '10:00', items: [{ length: '5 min', text: 'Item' }, { length: '15 min', text: 'Item' }, { length: '10 min', text: 'Item' }] }, 'How the agenda is built'),
   ];
   slides.forEach((s, i) => { s.n = i + 1; });
+  // the footer names the layout and the templates that use it (boards L01–L23)
+  for (const sl of slides) {
+    const uses = TEMPLATES.filter((t) => t.outline.some((o) => o.layout === sl.layout)).map((t) => t.name);
+    sl.source = ['Layout: ' + (NAMES[sl.layout] || sl.layout), uses.length ? uses.join(', ') : 'no template yet', 'placeholder data'].join(' · ');
+  }
   return { name: 'Slide layouts', today, slides };
 }
-const libraryHtml = (o) => RS.deckHtml(sampleDeck(o));
+/* THE TEMPLATES (canvas boards T02–T08). A template is a DEFAULT ORDER of layouts, never a fixed structure: the writer keeps what is true and
+ * adds or drops a slide when the findings say so (Wawan, 2026-11-03: no fixed structure). Each part: { part, layout }. A recurring report keeps
+ * the outline its readers agreed; a template only starts a report that has none. */
+const T = (id, name, title, sub, use, readers, cadence, parts) => Object.freeze({ id, name, title, sub, use, readers, cadence,
+  outline: Object.freeze(parts.map(([part, layout]) => Object.freeze({ part, layout }))) });
+const TEMPLATES = Object.freeze([
+  T('weekly-review', 'Weekly Review', 'Weekly Review: what moved, what slipped, what waits on you', 'Eight slides. Read in five minutes.', 'Every Monday for a team lead or sponsor.', 'team lead, sponsor', 'weekly',
+    [['Title with agenda', 'overview'], ['This week', 'tiles'], ['Key results', 'ledger'], ['What changed', 'compare'], ['The week', 'schedule'], ['Asks', 'decisions'], ['Next week', 'agenda'], ['Sources', 'sources']]),
+  T('program-kickoff', 'Program Kick-off', 'Program Kick-off: why, who, when, risks, first thirty days', 'Ten slides. Presented once, then kept as the charter.', 'At the start of a program or initiative.', 'sponsor, leads, partners', 'once per program',
+    [['Title', 'overview'], ['Why', 'statement'], ['Scope', 'lists'], ['People', 'people'], ['Milestones', 'timeline'], ['Risks', 'risks'], ['Ways of working', 'agenda'], ['Success', 'tiles'], ['First 30 days', 'focus'], ['Decisions', 'decisions']]),
+  T('meeting-recap', 'Meeting Recap', 'Meeting Recap: decisions, actions, open questions', 'Seven slides. The two-minute read for people who were not there.', 'Within an hour of a meeting.', 'attendees and absentees', 'after each meeting',
+    [['Title', 'overview'], ['The short version', 'agenda'], ['Decisions', 'quotes'], ['Action items', 'actions'], ['Discussion', 'minutes'], ['Open and parked', 'lists'], ['Next', 'next']]),
+  T('portfolio-snapshot', 'Portfolio Snapshot', 'Portfolio Snapshot: health, money, dependencies, decisions', 'Nine slides. One sitting.', 'For leadership who own several programs.', 'leadership', 'every two weeks',
+    [['Title', 'overview'], ['Health', 'donut'], ['Heatmap', 'heatmap'], ['Timeline', 'timeline'], ['Money and outcome', 'bubbles'], ['Top risks', 'risks'], ['Dependencies', 'network'], ['Spotlight', 'compare'], ['Decisions', 'decisions']]),
+  T('quarterly-review', 'Quarterly Review', 'Quarterly Review: answer first, then goals, bets, decisions', 'Nine slides. Leads with the answer, ends with sources.', 'At the end of each quarter.', 'leadership, board', 'quarterly',
+    [['Title', 'overview'], ['Answer', 'statement'], ['Scorecard', 'tiles'], ['Timeline', 'timeline'], ['Wins and misses', 'lists'], ['Risks', 'risks'], ['Bets', 'ranked'], ['Decisions', 'decisions'], ['Sources', 'sources']]),
+  T('decision-brief', 'Decision Brief', 'Decision Brief: the question, the options, the pick', 'Six slides. For a single call that needs a yes.', 'When one person must decide and needs the facts.', 'the decider', 'ad hoc',
+    [['The question', 'statement'], ['Options', 'compare'], ['Ranked by impact', 'ranked'], ['Risks of the pick', 'risks'], ['The ask', 'decisions'], ['Sources', 'sources']]),
+  T('incident-review', 'Incident Review', 'Incident Review: what happened, why, what we change', 'Six slides. Blameless and short.', 'Within a week of an incident.', 'engineering, support, leadership', 'after incident',
+    [['What happened', 'statement'], ['Timeline of the day', 'timeline'], ['Causes ranked', 'ranked'], ['What went well and not', 'lists'], ['Actions', 'actions'], ['Sources', 'sources']]),
+]);
+const templateOf = (id) => TEMPLATES.find((t) => t.id === id) || null;
+const NAMES = { overview: 'Overview', tiles: 'Tiles', ledger: 'Ledger', timeline: 'Timeline', compare: 'Compare', lists: 'Two lists', risks: 'Risk table', ranked: 'Ranked list',
+  decisions: 'Decisions', quotes: 'Quotes', actions: 'Actions', agenda: 'Agenda', heatmap: 'Heatmap', network: 'Network', schedule: 'Schedule', donut: 'Donut', bubbles: 'Bubbles',
+  people: 'People', statement: 'Statement', sources: 'Sources', minutes: 'Minutes', focus: 'Focus', next: 'Next' };
+/* One row per part (the agenda numbers them); past eight parts, two parts share a row ("Title · Why"), as the canvas cards pair them. */
+function cardRows(outline) {
+  const one = outline.map((o) => ({ title: o.part, text: NAMES[o.layout] || o.layout }));
+  if (one.length <= 8) return one;
+  const rows = [];
+  for (let i = 0; i < one.length; i += 2) rows.push(one[i + 1] ? { title: `${one[i].title} · ${one[i + 1].title}`, text: `${one[i].text} · ${one[i + 1].text}` } : one[i]);
+  return rows;
+}
+/** The template's card (boards T02–T08): its default order as numbered rows, and when to use it in the insight column. */
+function templateCard(t) {
+  return { layout: 'agenda', eyebrow: `${t.name} · Report template`, title: t.title, sub: t.sub,
+    data: { rows: cardRows(t.outline) },
+    insight: { head: 'When to use it', text: t.use, points: [{ tone: 'ok', text: `Readers: ${t.readers}` }, { tone: 'ok', text: `Cadence: ${t.cadence}` }, { tone: 'watch', text: 'Add or drop slides when the findings say so' }],
+      note: 'Order is the default; the writer may change it per report.' },
+    source: 'Template library · sample data' };
+}
+/** A template drawn with placeholder words: its card, then each part in its layout (the sample of that layout, titled by the part). */
+function templateDeck(id, o = {}) {
+  const t = templateOf(id);
+  if (!t) return null;
+  const lib = sampleDeck(o).slides;
+  const slides = [templateCard(t)].concat(t.outline.map((p) => { const s = lib.find((x) => x.layout === p.layout); return { ...s, eyebrow: `${t.name} · ${p.part}`, title: p.part, sub: s.title, source: 'Template library · placeholder data' }; }));
+  slides.forEach((s, i) => { s.n = i + 1; });
+  return { name: t.name, today: o.today || '2026-11-04', slides };
+}
+/** The library page: every layout, or one template (o.template). */
+const libraryHtml = (o = {}) => RS.deckHtml(o.template ? templateDeck(o.template, o) : sampleDeck(o));
 
-module.exports = { sampleDeck, libraryHtml };
+module.exports = { sampleDeck, libraryHtml, TEMPLATES, templateOf, templateCard, templateDeck };

package/workspace/lib/report-slides.js

@@ -33,7 +33,7 @@
  */
 
 const LAYOUTS = Object.freeze(['overview', 'tiles', 'ledger', 'timeline', 'compare', 'lists', 'risks', 'ranked', 'decisions', 'quotes', 'actions',
-  'agenda', 'heatmap', 'network', 'schedule', 'donut', 'bubbles', 'people', 'statement', 'sources', 'minutes', 'focus', 'next', 'blocks']);
+  'agenda', 'heatmap', 'network', 'schedule', 'donut', 'bubbles', 'people', 'statement', 'sources', 'minutes', 'focus', 'next', 'blocks', 'component']);
 const TONES = Object.freeze(['ok', 'watch', 'late', 'bad', 'info', 'none']);
 const MONS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
@@ -78,7 +78,7 @@ const SPEC = {
   decisions: { rows: { max: 3, min: 1, item: { question: 't', pick: 't', who: 't', by: 'date' } } },
   quotes: { agreed: 't', quotes: { max: 3, min: 1, item: { text: 't', who: 't', at: 't' } } },
   actions: { rows: { max: 6, min: 1, item: { text: 't', who: 't', due: 'date' } } },
-  agenda: { rows: { max: 5, min: 1, item: { title: 't', text: 't' } } },
+  agenda: { rows: { max: 8, min: 1, item: { title: 't', text: 't' } } },
   heatmap: { cols: { max: 6, min: 1, text: true }, total: 't', rows: { max: 6, min: 1, item: { name: 't', total: 't', cells: { max: 6, min: 1, item: { text: 't', tone: 'tone' } } } } },
   network: { nodes: { max: 8, min: 2, item: { id: 'id', label: 't', tone: 'tone' } }, edges: { max: 12, min: 1, pair: true } },
   schedule: { cols: { max: 7, min: 1, text: true }, rows: { max: 6, min: 1, item: { name: 't', from: 'i', to: 'i', text: 't', tone: 'tone' } } },
@@ -91,12 +91,13 @@ const SPEC = {
   focus: { gate: { obj: { title: 't', text: 't' } }, steps: { max: 4, min: 1, item: { label: 't', title: 't', text: 't' } } },
   next: { date: 'date', time: 't', items: { max: 6, min: 1, item: { length: 't', text: 't' } } },
   blocks: { blocks: { max: 12, min: 1, raw: true } },
+  component: {},
 };
 const REQUIRED = {
   overview: ['cols'], tiles: ['tiles'], ledger: ['rows'], timeline: ['rows'], compare: ['left', 'right'], lists: ['left', 'right'], risks: ['rows'],
   ranked: ['rows'], decisions: ['rows'], quotes: ['quotes'], actions: ['rows'], agenda: ['rows'], heatmap: ['cols', 'rows'], network: ['nodes', 'edges'],
   schedule: ['cols', 'rows'], donut: ['parts'], bubbles: ['points'], people: ['people'], statement: ['text'], sources: [], minutes: ['rows'],
-  focus: ['steps'], next: ['items'], blocks: ['blocks'],
+  focus: ['steps'], next: ['items'], blocks: ['blocks'], component: [],
 };
 const TEXT_MAX = 400;
 
@@ -133,6 +134,7 @@ function checkSpec(spec, data, at) {
 function layoutError(name, data) {
   if (!LAYOUTS.includes(name)) return `layout is one of ${LAYOUTS.join(', ')}`;
   if (!isObj(data)) return `data is the ${name} layout's object`;
+  if (name === 'component') return require('./report-slots.js').slotError(data);
   for (const k of REQUIRED[name]) if (data[k] == null || (Array.isArray(data[k]) && !data[k].length) || (isStr(data[k]) && !data[k].trim())) return `the ${name} layout needs ${k}`;
   const e = checkSpec(SPEC[name], data, 'data');
   if (e) return e;
@@ -154,7 +156,7 @@ function walk(spec, data, fn) {
   return out;
 }
 /** A copy of the data with fn applied to every text the writer wrote (the blocks layout is the engine's own and is left as it is). */
-const mapLayout = (name, data, fn) => (SPEC[name] && name !== 'blocks' ? walk(SPEC[name], data, fn) : data);
+const mapLayout = (name, data, fn) => (SPEC[name] && name !== 'blocks' && name !== 'component' ? walk(SPEC[name], data, fn) : data);
 /** Every text the writer wrote in the data. */
 function textsOfLayout(name, data) { const out = []; mapLayout(name, data, (t) => { out.push(t); return t; }); return out; }
 
@@ -188,6 +190,7 @@ function linesOf(name, d) {
     case 'focus': return [d.gate ? join(d.gate.title, d.gate.text) : ''].concat(L(d.steps, (s) => join(s.label, s.title, s.text))).filter(Boolean);
     case 'next': return [join(d.date ? longDate(d.date) : '', d.time)].concat(L(d.items, (x) => join(x.length, x.text))).filter(Boolean);
     case 'blocks': return L(d.blocks, (b) => (b.kind === 'p' ? b.text : b.kind === 'list' ? b.items.join(' · ') : b.kind === 'table' ? b.rows.map((r) => r.join(' | ')).join(' · ') : b.kind === 'bars' ? b.rows.map((r) => `${r.label}: ${r.text}`).join(' · ') : '')).filter(Boolean);
+    case 'component': return d.snapshot ? require('./report-slots.js').snapshotLines(d.snapshot) : [`The ${d.kind || ''} component ${d.ref || ''} is drawn when the report is written`];
     default: return [];
   }
 }
@@ -302,6 +305,13 @@ const BODY = {
     return `<div class="next-row">${when}<div class="fl"><div class="lb pb6">Draft agenda</div>${items}</div></div>`;
   },
   blocks(d) { return `<div class="blk">${d.blocks.map(blockHtml).join('')}</div>`; },
+  component(d) {
+    // PMOS's own component, as the snapshot PMOS took when the report was written (lib/report-slots.js); the writer never supplies this markup
+    const s = d.snapshot;
+    if (!isObj(s) || !isStr(s.html)) return `<div class="slot"><p class="ink2">This component is drawn from its record when the report is written.</p></div>`;
+    const when = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})$/.exec(str(s.at));
+    return `<div class="slot">${s.html}<span class="snap">Snapshot ${esc(when ? `${dmy(when[1])} ${when[2]}` : s.at)} · ${s.kind === 'kr' ? 'KR metric record' : 'record'} ${esc(s.ref)}</span></div>`;
+  },
 };
 const initials = (name) => str(name).split(/\s+/).filter(Boolean).slice(0, 2).map((w) => w[0].toUpperCase()).join('');
 const dueText = (ymd, today) => { const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(str(ymd)); return m ? `${DAYS[new Date(ms(ymd)).getUTCDay()].slice(0, 3)} ${+m[3]} ${MONS[+m[2] - 1]}${today && m[1] !== str(today).slice(0, 4) ? ' ' + m[1] : ''}` : str(ymd); };
@@ -574,6 +584,7 @@ width:1280px;height:720px;position:relative;overflow:hidden;box-sizing:border-bo
 .rs .kr,.rs .lrow,.rs .tb,.rs .btn,.rs .sb{transition:background-color .2s ease,box-shadow .2s ease}
 .rs .kr:hover,.rs .lrow:hover{background:rgba(244,243,240,.7)}
 .rs .tb:hover{box-shadow:0 2px 8px -2px rgba(42,46,53,.3)}
+${require('./report-slots.js').CSS}
 @media (prefers-reduced-motion:reduce){.rs *{animation:none!important;transition:none!important}}
 @media print{.rs *{animation:none!important;transition:none!important}.rs .ctl{display:none}}`;
 

package/workspace/lib/report-slots.js

@@ -0,0 +1,111 @@
+'use strict';
+/* report-slots.js — component slots on report slides (batch 27 item 14, PR 3; brief option B, "Component slots"). A slide can hold one of
+ * PMOS's own components, drawn by PMOS's own code from a PMOS record, never by the writer. The writer names the component and the record;
+ * PMOS reads the record when the report is written and keeps a DATED SNAPSHOT with the report, so an old issue stays true.
+ *
+ *   KINDS                          → the components a slot can hold today (each proven in the real reader; the rest were dropped)
+ *   slotError(data)                → null | a sentence: what is wrong with a section's { kind, ref, form } (pure)
+ *   snapshotOf(root, data, { now }) → Promise<{ ok, snapshot } | { ok: false, error }>: reads the record, draws the component
+ *   snapshotLines(snapshot)        → [line]: the component as plain lines, for the document and the PowerPoint file (pure)
+ *   CSS                            → the component's own styles, scoped to a slot (the workspace tokens, written out)
+ *
+ * A snapshot is { kind, ref, form, title, at, html, value, unit, readAt, series: [{ at, v }], target, chip, tone }. `html` is PMOS's markup:
+ * the report sanitizer still runs over the whole deck. The writer cannot pass a snapshot: lib/report-engine.js write() drops one it is given.
+ *
+ * WHICH COMPONENTS (the brief's proof rule: any component that fails the proof in the real reader is dropped, not faked):
+ *   kr   the KR metric tile of the Insights page (public/pm/premium-chart-draw.js tileHtml, from lib/insights-premium.js chartOf), in its four
+ *        forms: line, bars, meter, number. Pure strings; runs in Node; proven inside the reader's empty sandbox.
+ *   Dropped for now: the Board Timeline (bd-span.js needs the board's row model, its CSS and a mounted live copy; the library's own timeline
+ *   layout stands in), Document and Viewer (they mount DOM; they cannot be drawn into a sandboxed slide).
+ */
+const fs = require('fs');
+const path = require('path');
+
+const KINDS = Object.freeze(['kr']);
+const FORMS = Object.freeze(['line', 'bars', 'meter', 'number']);
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+const str = (v) => (typeof v === 'string' ? v : v == null ? '' : String(v));
+
+function slotError(d) {
+  if (!isObj(d)) return 'data is the component\'s object: { kind, ref, form }';
+  for (const k of Object.keys(d)) if (!['kind', 'ref', 'form', 'snapshot'].includes(k)) return `data.${k} is not part of a component slot; it takes kind, ref and form`;
+  if (!KINDS.includes(d.kind)) return `data.kind is one of ${KINDS.join(', ')} (the components PMOS can draw on a slide)`;
+  if (!/^[A-Za-z0-9_.:-]{1,100}$/.test(str(d.ref))) return 'data.ref is the id of the record the component shows (a KR metric record id)';
+  if (d.form != null && !FORMS.includes(d.form)) return `data.form is one of ${FORMS.join(', ')}`;
+  return null;
+}
+
+function recordsDir(root) {
+  try { const p = require(require('./repo-script.js').repoScript('signals/layout-paths.js')).pathsFor(root).recordsDir; if (p && fs.existsSync(p)) return p; } catch { /* fall through */ }
+  return path.join(root, 'planning', 'records');
+}
+const stamp = (now) => { const d = new Date(now); return `${d.toISOString().slice(0, 10)} ${d.toISOString().slice(11, 16)}`; };
+
+/** Read the record and draw the component. Async: the drawing code is the browser's own module, imported unchanged. */
+async function snapshotOf(root, d, { now = Date.now() } = {}) {
+  const e = slotError(d); if (e) return { ok: false, error: e };
+  if (d.kind === 'kr') {
+    let krs = [];
+    try { krs = require(require('./repo-script.js').repoScript('records/index.js')).list(recordsDir(root), 'kr-metrics'); } catch (x) { return { ok: false, error: `the KR metric records could not be read: ${str(x && x.message).slice(0, 120)}` }; }
+    const k = krs.find((x) => x.rid === d.ref);
+    if (!k) return { ok: false, error: `there is no KR metric record ${d.ref}. The records: ${krs.map((x) => x.rid).slice(0, 12).join(', ') || 'none'}` };
+    const today = new Date(now).toISOString().slice(0, 10);
+    const o = require('./routes-c3-strategy.js').outcomeOf(k, today);
+    const c = require('./insights-premium.js').chartOf(o);
+    if (!c) return { ok: false, error: `the KR metric ${d.ref} has fewer than two readings, so it has no chart yet` };
+    // Imported as source, not by path: the file has no imports of its own, and a path import makes newer Node print a module-type warning.
+    const src = fs.readFileSync(path.join(__dirname, '..', 'public', 'pm', 'premium-chart-draw.js'));
+    const draw = await import('data:text/javascript;base64,' + src.toString('base64'));
+    const form = d.form || 'line';
+    const html = draw.tileHtml({ ...c, form }).replace(/\stabindex="0"/g, '');
+    const last = o.readings[o.readings.length - 1];
+    const tone = c.chipKind === 'ok' ? 'ok' : c.chipKind === 'warn' ? 'watch' : c.chipKind === 'bad' ? 'bad' : 'none';
+    return { ok: true, snapshot: { kind: 'kr', ref: d.ref, form, title: c.title, at: stamp(now), html, value: last.v, unit: o.unit || '', readAt: last.at,
+      series: o.readings.map((r) => ({ at: r.at, v: r.v })), target: o.target, chip: c.chip, tone, valueText: c.v, targetText: c.targetTxt } };
+  }
+  return { ok: false, error: `no component ${d.kind}` };
+}
+
+/** The component as lines: the document and the PowerPoint file (dates in full). */
+function snapshotLines(s) {
+  if (!isObj(s)) return [];
+  const RS = require('./report-slides.js');
+  if (s.kind === 'kr') return [[s.title, s.valueText, s.targetText, s.chip].filter(Boolean).join(' · '), `Snapshot of the KR metric record ${s.ref}, last reading ${RS.dmy(s.readAt)}, taken ${RS.dmy(s.at.slice(0, 10))} ${s.at.slice(11)}`];
+  return [];
+}
+
+/* The tile's own rules (public/pm/premium.css), scoped to a slot, with the workspace tokens they read written out. No child combinator:
+ * the report sanitizer escapes `>` in CSS. */
+const CSS = `.rs .slot{--well:#F4F3F0;--ink:#2A2E35;--ink-2:#4A4F58;--ink-3:#646A74;--hair:rgba(42,46,53,.08);--ok:#3E6E49;--ember:#B8860B;--ember-ink:#8A5A00;--bad:#A8322A;--fs-display:44px;--lh-display:1.1;--fs-meta:13px;--lh-meta:1.4;--fs-badge:12px;--lh-badge:1.2;--fw-strong:600;display:flex;flex-direction:column;gap:10px;flex:1;min-height:0}
+.rs .slot .mt1{background:var(--well);border-radius:18px;padding:18px 22px 16px;display:grid;gap:4px;align-content:start}
+.rs .slot .mt1 span{font-size:var(--fs-meta);color:var(--ink-3);line-height:var(--lh-meta)}
+.rs .slot .mt1 b{font-size:var(--fs-display);font-weight:600;letter-spacing:-.03em;line-height:1.15}
+.rs .slot .mt1 em{font-style:normal;font-size:var(--fs-meta);color:var(--ink-3);line-height:var(--lh-meta)}
+.rs .slot .mt1.warn em{color:var(--ember-ink)}.rs .slot .mt1.bad em{color:var(--bad)}.rs .slot .mt1.ok em{color:var(--ok)}
+.rs .slot .mlab{display:flex;align-items:center;gap:8px;font-weight:600;color:var(--ink-2)}
+.rs .slot .mchip{font-style:normal;font-size:12px;font-weight:600;padding:2px 9px;border-radius:999px;background:#fff;color:var(--ink-2)}
+.rs .slot .mchip.ok{color:var(--ok)}.rs .slot .mchip.warn{color:var(--ember-ink)}
+.rs .slot .mchg{font-size:var(--fs-meta)}.rs .slot .mchg.good{color:var(--ok)}.rs .slot .mchg.bad{color:var(--bad)}
+.rs .slot .mfoot{display:flex;justify-content:space-between;font-size:12px;color:var(--ink-3)}.rs .slot .mfoot i{font-style:normal}
+.rs .slot svg{width:100%;height:auto;display:block;margin-top:8px;overflow:visible}
+.rs .slot .mch .ar{fill:rgba(42,46,53,.08);stroke:none}
+.rs .slot .mch .ln2{fill:none;stroke:var(--ink);stroke-width:1.8;stroke-linejoin:round;stroke-linecap:round;vector-effect:non-scaling-stroke}
+.rs .slot .mch .tg{stroke:var(--ink-3);stroke-dasharray:3 3;stroke-width:1;vector-effect:non-scaling-stroke}
+.rs .slot .mch .cx{display:none}
+.rs .slot .mch .dt{fill:var(--ink)}.rs .slot .mch.ok .dt{fill:var(--ok)}.rs .slot .mch.warn .dt{fill:var(--ember)}.rs .slot .mch.bad .dt{fill:var(--bad)}
+.rs .slot .mfm .mval{font-size:var(--fs-display);line-height:var(--lh-display)}
+.rs .slot .mfm .nspk{width:100%;height:auto;display:block;margin-top:8px;overflow:visible}
+.rs .slot .mfm .nspk path{fill:none;stroke:var(--ink-2);stroke-width:1.6;stroke-linecap:round;stroke-linejoin:round;vector-effect:non-scaling-stroke}
+.rs .slot .bplot{position:relative;display:flex;align-items:stretch;gap:2px;height:160px;margin-top:10px;border-bottom:1px solid var(--hair)}
+.rs .slot .bw{flex:1 1 0;display:flex;flex-direction:column;justify-content:flex-end;align-items:center;min-width:0;position:relative}
+.rs .slot .bw i{display:block;width:min(24px,64%);border-radius:4px 4px 0 0}
+.rs .slot .bw i.bg{background:rgba(42,46,53,.2)}.rs .slot .bw i.bk{background:var(--ink)}
+.rs .slot .bw .bl{font-size:12px!important;font-weight:600;margin-bottom:3px;white-space:nowrap;letter-spacing:0}
+.rs .slot .btg{position:absolute;left:0;right:0;border-top:1px dashed var(--ink-3);height:0}
+.rs .slot .mtrk{position:relative;height:12px;border-radius:999px;background:rgba(42,46,53,.1);margin:16px 0 8px}
+.rs .slot .mfil{position:absolute;inset:0 auto 0 0;border-radius:999px;background:var(--ink)}.rs .slot .mfil.ok{background:var(--ok)}.rs .slot .mfil.warn{background:var(--ember)}
+.rs .slot .mtgt{position:absolute;top:-5px;bottom:-5px;width:2px;background:var(--ink);border-radius:2px}
+.rs .slot .mnote,.rs .slot .mwhy{font-size:var(--fs-meta);color:var(--ink-3)}
+.rs .snap{align-self:flex-start;display:inline-flex;align-items:center;height:22px;padding:0 9px;border-radius:999px;font-size:12px;font-weight:600;background:var(--well);color:var(--ink-3)}`;
+
+module.exports = { KINDS, FORMS, slotError, snapshotOf, snapshotLines, CSS };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.531.0",
+  "version": "0.533.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.531.0",
+      "version": "0.533.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.531.0",
+  "version": "0.533.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/skills/report-write.skill

@@ -26,17 +26,20 @@ Procedure:
 1. Run `pmos report make <id>`. For an ad hoc report add `--ask "<the question>"`, and `--readers "<who>"` when you know them. Name sources the brief must read with `--source`, comma-separated: `connector:<name>=<what it is>` (Jira, BigQuery for GA4, Confluence, …), `document:<path>`, `pack:<state file of readings>`, `pmos` (the PMOS ledgers). It writes `<slot>.brief.json`, `<slot>.readings.json` and `<slot>.findings.json` next to the draft, and prints the gaps.
    - If it refuses because the slot is issued, stop: an issued report is frozen.
    - If it says there is no report with that id, it needs a question: ask the PM once for the question, or take it from the chat line.
+   - When the PM names a kind of report that a template fits (a weekly review, a kick-off, a meeting recap, a portfolio snapshot, a quarterly review, a decision brief, an incident review), add `--template <id>`.
 2. Read `<slot>.brief.json`: the readers, the questions, the window, the sources, the last issue, the agreed outline, the carried asks, the voice and the rules.
 3. Read each source that the gaps name, through its connector or the file, read-only. Write what you read as readings in one JSON file: `{"readings":[{"id":"web-login-rate","value":81,"unit":"%","n":597,"of":733,"at":"2026-10-19","source":"ga4","how":"events_20261019, sessions with a password start","label":"Web password login, recorded success"}],"gaps":[{"source":"native-app","reason":"read only on the device"}]}`. Give `target` and `better` ("higher" or "lower") when the reading has a target. Give `flag` when the reading is off what the readers expect. Run `pmos report read <id> --from <file>`. A parameter of a method (a 5-second match window) is a reading too.
 4. Find what answers the readers. Write the findings that answer each question, each citing the readings it rests on, and run `pmos report find <id> --from <file>` with `{"findings":[{"text":"…","readings":["…"],"kind":"answers-question","question":"…"}]}`. The engine adds its own findings: changes since the last issue, misses against a target, initiatives off plan, items due within 14 days, the asks carried over. If `<slot>.findings.json` says `"none": true`, there is nothing to report: stop and say so in one line. Do not write a report about nothing.
 5. Choose the outline for these readers and this question. Any sections, any titles, any order.
    - A recurring report keeps `agreed_outline`, the sections of its last issued issue. Add a section only when a finding needs one, drop one only when it would be empty, and say so in `outline_note` (one line).
    - `earlier_outline` is the shape of an issue written before the engine (the old fixed frame). It is an example, not an agreement: keep what served the readers.
+   - `template` is set when the PM started the report from a report template (`pmos report make <id> --template <name>`; `pmos report library --json` lists them). Its `outline` is a default order of parts, each with its slide layout: use it as the starting outline, retitle each part as a finding, and add or drop a part when the findings say so. An agreed outline wins over a template.
    - Each section title is a finding, not a label: "Sign-up stalls before submit", not "Sign-up". Reading only the titles tells the story.
    - Shapes other reports took, as examples and never a menu: a decision (the lean · the options and what each costs · what could reverse it · your call); a watch (today against yesterday and the week · the drop that moved most · why); a stakeholder update (are the dates on track · what each team needs and by when · open decisions · what could stop it); a review (the summary for decision · the outcomes by segment · the challenges and answers · method); did-it-work (what was promised · what we got · the verdict).
 6. Write `<slot>.report.json` (in a scratch file, then `pmos report write <id> --from <file>`):
    `{"title":"…{{r:…}}…","answer":{"text":"…","supports":["Label: …{{r:…}}…"]},"sections":[{"id":"…","title":"…","blocks":[{"kind":"p","text":"…"},{"kind":"list","items":["…"]},{"kind":"table","columns":["…"],"rows":[["…"]]},{"kind":"bars","title":"…","rows":[["label","{{r:id}}"]]},{"kind":"options","options":[{"name":"…","text":"…"}]},{"kind":"quote","text":"…"}]}],"ask":{"text":"…","who":"…","by":"YYYY-MM-DD","options":["…"]},"beyond":{"why":"…","so_what":"…","now_what":"…","since":"…","would_change":"…","unknown":["…"],"else":["…"],"next_question":"…"},"questions":[{"question":"<a question of the brief>","answered_in":"<section id or answer>","gap":"<why it cannot be answered>"}],"outline_note":"…"}`.
    - A section can take a slide layout from the report library instead of blocks: `{"title":"…","layout":"<name>","data":{…},"insight":{"head":"…","text":"…","points":[{"tone":"ok|watch|late|bad|info|none","text":"…"}],"note":"…"},"eyebrow":"…","sub":"…"}`. The names: overview, tiles, ledger, timeline, compare, lists, risks, ranked, decisions, quotes, actions, agenda, heatmap, network, schedule, donut, bubbles, people, statement, sources, minutes, focus, next. Run `pmos report library` to see each one with its data; `pmos report write` names a field that does not fit. Pick the layout that fits the finding, never to fill a slide. Every text in `data` and `insight` is checked like any other: a figure is a reading token. A bar's `share`, a `target` mark and a bubble's `x`, `y` and `size` are numbers from 0 to 1: take them from the readings. The insight is optional; leave it out when the slide says it already.
+   - A section can also hold a PMOS component, drawn by PMOS from a PMOS record: `{"title":"…","layout":"component","data":{"kind":"kr","ref":"<KR metric record id>","form":"line|bars|meter|number"}}`. Today the one component is `kr`, the KR metric tile of the Insights page; the record needs two readings or more. Do not write the drawing: `pmos report write` reads the record, draws the tile and keeps a dated snapshot with the report, so an old issue keeps the figures of its day. It refuses a record that is not there and names the records that are.
    - `ask` is null when the readers have nothing to decide. When it is a call with no better option on the evidence, give the options and say "your call".
    - BEYOND THE ASK. Answer the readers' next three questions before they ask: why (the cause, from the evidence), so what (the effect on the target and its date), now what (the recommendation, who, by), since the last issue (what moved, and each carried ask), what would change it (the one or two readings that would flip the recommendation), what we don't know (the gaps, counted, never padded), what else is here (at most two findings from a named source the readers did not ask about, when their question depends on them) and the next question (the split they will ask for next). Each part cites a reading. Leave a part out when no reading backs it, and leave out a part the brief's rules turn off.
    - `questions`: map each question of the brief after the first to the section that answers it, or give the gap.