create-pmos 0.529.0 → 0.531.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.529.0",
+  "version": "0.531.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.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",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1246,
+          "t": "Send meeting captures to Jev and keep only the slide (MpJ)",
+          "s": "Send meeting captures to Jev and keep only the slide (MpJ)",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.529.0",
       "at": "2026-11-04T13:14:44.790Z",
@@ -393,54 +419,6 @@
           "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."
-        }
-      ]
-    },
-    {
-      "v": "0.510.0",
-      "at": "2026-11-03T14:33:47.373Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1197,
-          "t": "Clean Updates lines: no, one PR number, no repeated title, right group",
-          "s": "Clean Updates lines: no, one PR number, no repeated title, right group",
-          "k": "fix",
-          "h": "Clearer update notes",
-          "d": "Update notes could repeat a line, show odd tags, or put every change under Improved. Now each change shows once, in the right group."
-        },
-        {
-          "n": 1199,
-          "t": "A Board product head's name opens its page in the Viewer",
-          "s": "A Board product head's name opens its page in the Viewer",
-          "k": "new"
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@96caad55
+kernel-source: pmos@add0a4c9
 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-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T18:44:47Z"}
 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-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T18:44:47Z"}
 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-04T13:14:41Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T18:44:47Z"}
 status: stable
 ---
 

package/workspace/changelog.json

@@ -1,4 +1,30 @@
 [
+ {
+  "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",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1246,
+    "t": "Send meeting captures to Jev and keep only the slide (MpJ)",
+    "s": "Send meeting captures to Jev and keep only the slide (MpJ)",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.529.0",
   "at": "2026-11-04T13:14:44.790Z",

package/workspace/guide/notes.md

@@ -190,7 +190,7 @@ Without Jev, the workspace labels each line with its own rules and finds the clo
 1. Save a TypeSafe key and switch on validation for the repository (see [Validate with TypeSafe](validate-with-typesafe.md)).
 2. Open the settings and switch on **Label lines with Jev**. Switch on **Check notes against this repository with Jev** for the checks too. Both are off until you switch them on, for each repository.
 
-With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Audio, speaker names and private notes never go. A line that looks like a secret is not sent.
+With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Each screen capture goes too, so Jev can find the slide or document in it (see the meeting player below). Audio, speaker names and private notes never go. A line that looks like a secret is not sent, and a capture set aside as another app is not sent.
 
 ## Correct and tag a line
 
@@ -253,7 +253,7 @@ A meeting with a recording opens wide, in two columns. Press **Back to the side*
 
 The captures row is hidden until you press the captures icon. It shows the five captures near the playing time, and **+N more** shows the rest.
 
-When Jev is on for the repository (Settings › **Label lines with Jev**) and Jev gave a box for a capture, the player and the captures row show only the slide or document in that box. The meeting window and the faces are cut off, and a capture that shows only faces is not in the captures row. The icon at the top right of the picture shows the whole frame. When Jev is off, or gave no box, you see the whole frame. Note: PMOS does not yet send the captures to Jev, so for now every capture shows the whole frame.
+When Jev is on for the repository (Settings › **Label lines with Jev**) and Jev gave a box for a capture, the player and the captures row show only the slide or document in that box. The meeting window and the faces are cut off, and a capture that shows only faces is not in the captures row. The icon at the top right of the picture shows the whole frame. When Jev is off, or gave no box, you see the whole frame. Captures kept before you switched Jev on are sent the next time you open the meeting. Jev reads pictures up to 1568 px a side. On a Mac a larger capture from an earlier meeting is made smaller first; on another computer it shows the whole frame.
 
 ### Fix a word that was heard wrong
 

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,8 @@ 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.
+
 Every command accepts `--root <dir>` to name the repository. `draft` and `list` also accept `--json`.
 
 ## The window

package/workspace/lib/jev-notes.js

@@ -4,6 +4,7 @@
  *   gatesFor(key, flags) · checkGatesFor(key, flags) · senderFor(key, flags, askOpts) · infoFor(present, flags)
  *   label({ ask, key, askOpts, text, pause })            → { cat, p } | { cat: null, reason }
  *   compare({ ask, key, askOpts, text, passage, pause }) → { verdict: 'agrees'|'differs'|'related', words } | { verdict: null, reason }
+ *   screen({ askImage, key, askOpts, image, root })      → { kind: 'slide'|'document'|'faces'|'unsure', box?, p } | { kind: null, reason }
  *   getSwitch(runtimeDir, root) · setSwitch(runtimeDir, root, { jev, check })
  *
  * WHAT MAY LEAVE THE MACHINE. For a label: one cleaned transcript line and one Choice question. For a check: the line and
@@ -13,6 +14,9 @@
  * per-user runtime directory. Never sent: audio, a speaker's name, a line or passage the secret scan matches, a private
  * note (the caller refuses it before this module), anything while paused.
  *
+ * For a screen capture (MpJ): the capture's picture and nothing else, with one Choice and one Box question, under the same three
+ * gates. The caller sends only shots the note lists: never a shot set aside as another app, never one from a private note.
+ *
  * WHAT A RESULT IS. Advisory (D40), shown in words. A label under UNSURE_BELOW keeps the local label. A check says
  * "agrees" or "differs" only above SURE; otherwise "related", which is what the local match alone also says.
  *
@@ -68,8 +72,8 @@ const checkGatesFor = (key, f) => checkGates({ key: typesafe.validKey(key), cons
 /** { ask, check, askOpts }: `ask` sends labels and `check` is true when checks may also be sent. Both shut when a gate is. */
 function senderFor(key, flags, askOpts = {}) {
   const g = gatesFor(key, flags);
-  if (!g.open) return { ask: null, check: false, gates: g, askOpts: {} };
-  return { ask: (a) => typesafe.ask(a), check: checkGatesFor(key, flags).open, gates: g, askOpts: { ...NOTES_ASK, ...askOpts } };
+  if (!g.open) return { ask: null, askImage: null, check: false, gates: g, askOpts: {} };
+  return { ask: (a) => typesafe.ask(a), askImage: (a) => typesafe.askImage(a), check: checkGatesFor(key, flags).open, gates: g, askOpts: { ...NOTES_ASK, ...askOpts } };
 }
 /** What the view needs to explain the two switches. Booleans and sentences only. */
 function infoFor(present, flags) {
@@ -86,6 +90,11 @@ function getSwitch(runtimeDir, root) {
   const r = s && s.repos && root ? s.repos[root] : null;
   return { jev: !!(r && r.jev === true), check: !!(r && r.check === true) };
 }
+/** The repositories whose switch "notes may use Jev" is on, sorted: a note bound to no repository looks at its shots under the first of these that also has consent (routes-notes.js lookAtShots). */
+function onRoots(runtimeDir) {
+  const s = readJson(switchFile(runtimeDir), {});
+  return Object.entries((s && s.repos) || {}).filter(([, v]) => v && v.jev === true).map(([r]) => r).sort();
+}
 function setSwitch(runtimeDir, root, { jev, check } = {}) {
   const s = readJson(switchFile(runtimeDir), {});
   const prev = getSwitch(runtimeDir, root);
@@ -156,7 +165,53 @@ async function compare({ ask, key, askOpts = {}, text, passage, root = '' }) {
   if (same != null && same >= SURE) return { verdict: 'agrees', words: wordsFor(same), model: res.model || null };
   return { verdict: 'related', words: null, model: res.model || null };
 }
+/* ── screen captures (MpJ) ──────────────────────────────────────────────────────────────────────── */
+const SHOT_KINDS = {
+  slide: 'A shared slide or presentation is on the screen.',
+  document: 'A shared document, web page, spreadsheet, board or app screen is on the screen.',
+  faces: 'Only the people in the meeting: their video tiles, pictures or names. Nothing is shared.',
+  other: 'Something else, such as an empty, loading or desktop screen.',
+};
+const SHOT_KIND_Q = 'The `capture` is a screenshot taken during a video meeting. What does it mainly show?';
+const SHOT_BOX_Q = 'the shared slide or document in `capture`, without the meeting app\'s toolbars and without the video tiles of the people';
+const SHOT_SHOWN = ['slide', 'document'];
+const SHOT_ASK = { timeoutMs: 20000, retries: 1, backoffMs: 600 };
+const r4 = (n) => Math.round(n * 10000) / 10000;
+/** Jev's { top, bottom, left, right } (fractions of the picture) as [x, y, w, h], or null when it is not a useful crop. */
+function boxOf(ans) {
+  const b = ans && ans.box;
+  if (!b || typeof b !== 'object') return null;
+  const [t, bo, l, ri] = [b.top, b.bottom, b.left, b.right].map(Number);
+  if (![t, bo, l, ri].every((v) => Number.isFinite(v) && v >= -0.01 && v <= 1.01)) return null;
+  const x = Math.max(0, l), y = Math.max(0, t), w = Math.min(1, ri) - x, h = Math.min(1, bo) - y;
+  if (!(w > 0.1) || !(h > 0.1)) return null;          // a sliver is not a slide
+  if (w * h > 0.95) return null;                       // the whole frame already: nothing to crop
+  return [r4(x), r4(y), r4(w), r4(h)];
+}
+/** What one capture shows, from Jev. Faces are named only when Jev is sure; a crop only for a slide or a document. */
+async function screen({ askImage, key, askOpts = {}, image, root = '' }) {
+  const p = pauseOf(root);
+  if (!askImage) return { kind: null, reason: 'off' };
+  if (p.paused) return { kind: null, reason: 'paused', sentence: p.paused };
+  const questions = { kind: { type: 'choice', instructions: SHOT_KIND_Q, criteria: SHOT_KINDS }, area: { type: 'box', instructions: SHOT_BOX_Q } };
+  const res = await askImage({ key, image, name: 'capture', questions, ...SHOT_ASK, ...askOpts });
+  if (!res.requested) return { kind: null, reason: 'refused', sentence: res.reason || null };
+  note(p, res);
+  if (!res.ok) return { kind: null, reason: 'failed', sentence: res.reason || null };
+  const probs = choiceProbs(res.answers && res.answers.kind);
+  const top = Object.entries(probs).filter(([k]) => SHOT_KINDS[k]).sort((a, b) => b[1] - a[1])[0];
+  const model = res.model || null;
+  if (!top) return { kind: null, reason: 'unreadable' };
+  if (top[0] === 'faces' && top[1] >= SURE) return { kind: 'faces', p: r4(top[1]), model };
+  if (SHOT_SHOWN.includes(top[0]) && top[1] >= UNSURE_BELOW) {
+    const box = boxOf(res.answers && res.answers.area);
+    return box ? { kind: top[0], box, p: r4(top[1]), model } : { kind: top[0], p: r4(top[1]), model };
+  }
+  return { kind: 'unsure', p: r4(top[1]), model };
+}
+
 function pauseStatus(root) { const p = pauses.get(root); return p && p.paused ? p.paused : null; }
 
-module.exports = { gates, checkGates, gatesFor, checkGatesFor, gateSentence, senderFor, infoFor, getSwitch, setSwitch, label, compare, choiceProbs, pauseStatus,
+module.exports = { gates, checkGates, gatesFor, checkGatesFor, gateSentence, senderFor, infoFor, getSwitch, setSwitch, onRoots, label, compare, screen, boxOf,
+  pictures: { imageSize: typesafe.imageSize, imageRefusal: typesafe.imageRefusal, IMAGE_SIDE: typesafe.IMAGE_SIDE }, choiceProbs, pauseStatus, SHOT_KINDS,
   CATS, UNSURE_BELOW, SURE, REJECTED_LIMIT, UNREACHABLE_LIMIT };

package/workspace/lib/jev-screen.js

@@ -0,0 +1,110 @@
+'use strict';
+/* jev-screen.js — Jev looks at a note's screen captures and keeps only the useful area (batch 27 item 12, board MpJ).
+ *
+ *   run({ runtimeDir, id, g, screen?, jev?, fit? }) → Promise<{ asked, kept, skipped, stopped? }>
+ *   busy(id) → boolean                   a run for the note is in progress
+ *   fitFor(buf, { platform?, sips? }) → Promise<{ buf } | { reason }>   a picture in Jev's size range, or why there is none
+ *
+ * WHAT IT DOES. For each shot the note lists that has no `jev` yet, in meeting-time order, it sends the picture to Jev
+ * (lib/jev-notes.js screen, through lib/typesafe.js askImage) and keeps the answer on the shot's row in the index:
+ *   { kind: 'slide'|'document', box: [x, y, w, h] }   the page shows only the box, with the whole-frame icon (premium-mtg-replay.js)
+ *   { kind: 'faces' }                                 the page leaves the shot out of the captures row
+ *   { kind: 'slide'|'document'|'unsure' } (no box)    the page shows the whole frame, as without Jev
+ *   { kind: 'skip', why }                             not sent (out of Jev's size range and no way to resize here); whole frame
+ * x, y, w, h are fractions of the picture, so they hold for the kept file at any size.
+ *
+ * GATES. `g` is routes-notes.js gatesFor: no `askImage` (no key, no consent, the switch "notes may use Jev" off) means no
+ * request. Private notes and shots set aside as another app are never sent: the caller passes only an open note, and
+ * notes-screen.js list leaves set-aside shots out. It waits for the text reads first, because a text read is what sets a
+ * shot aside. A failed ask leaves the row as it was, so the next run asks again; a pause (jev-notes.js) stops the run.
+ *
+ * SIZE. Jev does not resize: each side 280 to 1568 px. The page captures at most 1568 px a side (notes-screen-capture.js);
+ * older shots were 1600 px wide. On a Mac, `sips` (part of macOS) makes a smaller copy in the temp folder, which is sent and
+ * deleted. Elsewhere such a shot is marked skip and shows whole.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+const jevNotes = require('./jev-notes');
+// the size rules come through the notes bridge: only the bridges require lib/typesafe.js (no-network.test.js)
+const typesafe = jevNotes.pictures;
+const notesScreen = require('./notes-screen');
+
+const SIPS = '/usr/bin/sips';
+const MAX_PER_RUN = 400;
+const running = new Map();   // note id → the run in progress, so two triggers never ask twice for one shot
+
+/** A copy of the picture in Jev's size range, made by sips on a Mac. */
+function fitFor(buf, { platform = process.platform, sips = SIPS } = {}) {
+  const size = typesafe.imageSize(buf);
+  if (!size) return Promise.resolve({ reason: 'not a PNG or a JPEG' });
+  if (!typesafe.imageRefusal(size, buf.length)) return Promise.resolve({ buf });
+  const { min, max } = typesafe.IMAGE_SIDE;
+  if (size.w < min || size.h < min) return Promise.resolve({ reason: `${size.w} × ${size.h} px is smaller than Jev reads` });
+  let can = platform === 'darwin';
+  try { fs.accessSync(sips, fs.constants.X_OK); } catch { can = false; }
+  if (!can) return Promise.resolve({ reason: `${size.w} × ${size.h} px is larger than Jev reads, and this machine cannot make it smaller` });
+  const tmp = path.join(os.tmpdir(), 'pmos-jev-' + crypto.randomBytes(6).toString('hex'));
+  const src = tmp + '.' + size.format, out = tmp + '-fit.' + size.format;
+  return new Promise((resolve) => {
+    try { fs.writeFileSync(src, buf, { mode: 0o600 }); } catch { resolve({ reason: 'the temp folder cannot be written' }); return; }
+    execFile(sips, ['-Z', String(max), src, '--out', out], { timeout: 20000, windowsHide: true }, (err) => {
+      let fit = null;
+      try { if (!err) fit = fs.readFileSync(out); } catch { fit = null; }
+      for (const f of [src, out]) { try { fs.unlinkSync(f); } catch { /* gone */ } }
+      const s2 = fit ? typesafe.imageSize(fit) : null;
+      resolve(fit && s2 && !typesafe.imageRefusal(s2, fit.length) ? { buf: fit } : { reason: 'the smaller copy could not be made' });
+    });
+  });
+}
+
+async function runNow({ runtimeDir, id, g, screen = notesScreen, jev = jevNotes, fit = fitFor }) {
+  const out = { asked: 0, kept: 0, skipped: 0 };
+  if (!g || !g.askImage) return { ...out, stopped: 'off' };
+  await screen.ocrIdle();
+  const todo = screen.list(runtimeDir, id).filter((f) => !f.jev).slice(0, MAX_PER_RUN);
+  for (const f of todo) {
+    const buf = screen.readShot(runtimeDir, id, f);
+    if (!buf) continue;
+    const ok = await fit(buf);
+    if (!ok.buf) { screen.setJev(runtimeDir, id, f, { kind: 'skip', why: ok.reason }); out.skipped++; continue; }
+    out.asked++;
+    const r = await jev.screen({ askImage: g.askImage, key: g.key, askOpts: g.askOpts, image: ok.buf, root: g.root });
+    if (r.reason === 'paused') return { ...out, stopped: 'paused' };
+    if (r.reason === 'refused') { screen.setJev(runtimeDir, id, f, { kind: 'skip', why: r.sentence || 'refused' }); out.skipped++; continue; }
+    if (!r.kind) continue;   // failed or unreadable: asked again next run
+    const row = { kind: r.kind, at: Date.now() };
+    if (r.box) row.box = r.box;
+    if (r.p != null) row.p = r.p;
+    if (r.model) row.model = r.model;
+    if (screen.setJev(runtimeDir, id, f, row)) out.kept++;
+  }
+  return out;
+}
+
+/** Ask Jev about the note's shots that have no answer yet. One run per note at a time: a call during a run makes the run
+ * go once more at its end, so a shot kept meanwhile is asked about too. */
+function run(a) {
+  const cur = running.get(a.id);
+  if (cur) { cur.again = a; return cur.p; }
+  const st = { again: null, p: null };
+  st.p = (async () => {
+    let last;
+    let next = a;
+    while (next) {
+      st.again = null;
+      last = await runNow(next).catch(() => ({ asked: 0, kept: 0, skipped: 0, stopped: 'error' }));
+      next = last.stopped ? null : st.again;
+    }
+    return last;
+  })().finally(() => running.delete(a.id));
+  running.set(a.id, st);
+  return st.p;
+}
+
+/** Whether Jev is looking at this note's shots right now (the replay tells the page to read again when it ends). */
+const busy = (id) => running.has(id);
+
+module.exports = { run, busy, fitFor, MAX_PER_RUN };

package/workspace/lib/meeting-replay.js

@@ -107,11 +107,14 @@ function timeOfKey(item, lines) {
 
 /** What Jev for images said of a shot (batch 27 item 12, MpJ), when a shot's index row holds it: the kind ('content', a slide or a
  * document; 'faces', only people) and the box around the useful area, as fractions of the frame [x, y, w, h]. Anything else is dropped. */
+/* lib/jev-screen.js keeps Jev's kind as slide or document; both are content here */
+const CONTENT = ['content', 'slide', 'document'];
 function jevOf(j) {
-  if (!j || typeof j !== 'object' || !['content', 'faces'].includes(j.kind)) return null;
+  if (!j || typeof j !== 'object' || !(CONTENT.includes(j.kind) || j.kind === 'faces')) return null;
   const b = Array.isArray(j.box) && j.box.length === 4 && j.box.every((x) => Number.isFinite(x) && x >= 0 && x <= 1) ? j.box.map((x) => Math.round(x * 1000) / 1000) : null;
   const box = b && b[2] >= 0.05 && b[3] >= 0.05 && b[0] + b[2] <= 1.001 && b[1] + b[3] <= 1.001 ? b : null;
-  return { kind: j.kind, ...(box && j.kind === 'content' ? { box } : {}) };
+  const kind = j.kind === 'faces' ? 'faces' : 'content';
+  return { kind, ...(box && kind === 'content' ? { box } : {}) };
 }
 
 /** Join the three records. */

package/workspace/lib/notes-screen.js

@@ -5,6 +5,7 @@
  *   list(runtimeDir, id) → [{ t, file, w, h, bytes, why?, text? }]   sorted by t; empty when the note has none
  *   serve(req, res, runtimeDir, id, t)        the shot at t as its image, cached for good; 404 JSON when there is none
  *   remove(runtimeDir, id) → boolean          delete the note's screenshots
+ *   readShot(runtimeDir, id, frame) → Buffer | null · setJev(runtimeDir, id, frame, jev) → boolean   what Jev saw in a shot (lib/jev-screen.js)
  *   getOn(runtimeDir) · setOn(runtimeDir, bool)   "Capture the shared screen", on by default, for this machine
  *   ocrDetect({ env? }) → { bin } | null      the tesseract the PM installed
  *   ocrIdle() → Promise                       resolves when the text queue is empty (tests)
@@ -294,7 +295,20 @@ function readText(bin, runtimeDir, id, frame) {
     });
   });
 }
+/** The bytes of one listed shot, or null. */
+function readShot(runtimeDir, id, frame) {
+  if (!ID_RE.test(String(id || '')) || !frame || !FILE_RE.test(String(frame.file || ''))) return null;
+  try { return fs.readFileSync(path.join(dirOf(runtimeDir, id), frame.file)); } catch { return null; }
+}
+/** Keep what Jev saw in a shot ({ kind, box?, … }) on its row, only if the same shot is still there and not set aside. */
+function setJev(runtimeDir, id, frame, jev) {
+  const rows = readIndex(runtimeDir, id);
+  const row = rows.find((f) => f.t === frame.t && f.file === frame.file && f.bytes === frame.bytes && !f.aside);
+  if (!row) return false;
+  row.jev = jev;
+  try { writeIndex(runtimeDir, id, rows); return true; } catch { return false; }
+}
 /** Resolves when every text read queued so far has ended. */
 function ocrIdle() { return queue.then(() => (waiting > 0 ? ocrIdle() : undefined)); }
 
-module.exports = { add, list, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };
+module.exports = { add, list, readShot, setJev, listAside, asideCount, keep, discard, discardAll, sweepAside, classifyShot, setHints, ASIDE_DAYS, serve, remove, getOn, setOn, ocrDetect, ocrIdle, kindOf, MAX_SHOT_BYTES, MAX_SHOTS, MAX_BYTES };

package/workspace/lib/report-cli.js

@@ -37,7 +37,7 @@ 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>]',
@@ -54,6 +54,8 @@ 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',
+  '      Writes one HTML page (default: report-library.html in the current folder). Open it in a browser to check the look.',
   '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 +76,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 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'] };
+  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 CADENCE_RE = /^[a-z][a-z0-9-]{0,39}$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -145,6 +147,17 @@ 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');
+    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());
+    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 });