create-pmos 0.532.0 → 0.533.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.532.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,19 @@
     "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",
@@ -406,19 +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"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@c8e1d796
+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-04T19:01:32Z"}
+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-04T19:01:32Z"}
+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-04T19:01:32Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T19:35:08Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,17 @@
 [
+ {
+  "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",

package/workspace/guide/reports.md

@@ -94,6 +94,8 @@ pmos report issue biweekly 2026-10-16
 
 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

@@ -208,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; }
@@ -252,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

@@ -703,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
@@ -795,7 +796,7 @@ function make(root, id, { slot, ask, readers, sources, template, add, gaps, addF
 }
 
 /** 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`);
@@ -805,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-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'];
@@ -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.532.0",
+  "version": "0.533.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.532.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.532.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

@@ -39,6 +39,7 @@ Procedure:
 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.