create-pmos 0.529.0 → 0.531.0

package/workspace/lib/routes-meeting-replay.js

@@ -5,7 +5,8 @@
  *   GET /api/meeting-replay?event=<id>[&date=YYYY-MM-DD]          the note linked to that meeting
  *        → { ok, note, meeting, audio, start_ms, length_ms, lines, keys, topics, runs, notes, shots, aside_count }   (lib/meeting-replay.js)
  *        The note (transcript, decisions, next steps, questions), the Focus state file (topics, stretches, PMOS's notes) and the
- *        shots, joined. Read only: it writes nothing, starts no run and reaches nothing outside the machine. A private note is a
+ *        shots, joined. It writes nothing itself. When kept shots have no answer from Jev yet and the gates let notes use Jev, the
+ *        handler starts Jev on them in the background (routes-notes.js lookAtShots) and sets `jev_running`. A private note is a
  *        404 (it keeps no audio and no shots); an unknown note or a meeting with no note is a 404. A shot that was set aside
  *        (`aside`) is not in `shots`; `aside_count` says how many there are.
  * Handlers are pure over (query, ctx): ctx = { runtimeDir, readEvents?, now? }, so a test needs no server.
@@ -16,6 +17,7 @@ const notesAudio = require('./notes-audio.js');
 const notesScreen = require('./notes-screen.js');
 const F = require('./meeting-focus.js');
 const R = require('./meeting-replay.js');
+const jevScreen = require('./jev-screen.js');
 
 const fail = (status, error) => ({ status, body: { ok: false, error } });
 const DAY = /^\d{4}-\d{2}-\d{2}$/;
@@ -59,6 +61,8 @@ async function read(q, ctx) {
   const rec = notesAudio.info(dir, note.id);
   const audio = rec ? { url: '/api/notes/recording?id=' + encodeURIComponent(note.id) + '&b=' + rec.bytes + (notesAudio.hasClean(dir, note.id) ? '&c=1' : ''), ms: rec.ms } : null;
   const body = R.build({ note, event: ev, stateLines: focus.linesOf(dir, keys), frames: framesOf(dir, note.id), audio, topics: talk ? [] : F.topicsFrom(ev, null), now: nowMs });
+  // Jev is cutting this note's shots to the slide now (opening the note starts it, lib/routes-notes.js): the page reads the replay again
+  if (jevScreen.busy(note.id)) body.jev_running = true;
   return { status: 200, body };
 }
 
@@ -70,6 +74,13 @@ module.exports = {
   handle: async (req, res, url, ctx) => {
     if (url.pathname !== '/api/meeting-replay') return false;
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
-    return respond(ctx, res, await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json }));
+    const r = await read(Object.fromEntries(url.searchParams), { runtimeDir: ctx.runtimeDir, json: ctx.json });
+    // shots Jev has not looked at (a past meeting, kept before Jev was on): start Jev on them in the background, as GET
+    // /api/notes/one does, so a replay opened from the calendar is cut to the slide too. It never blocks the answer.
+    const nid = r.status === 200 && r.body && r.body.note ? r.body.note.id : null;
+    if (nid && !r.body.jev_running && notesScreen.list(ctx.runtimeDir, nid).some((f) => !f.jev)) {
+      try { if (require('./routes-notes.js').lookAtShots(ctx, nid)) r.body.jev_running = true; } catch { /* advisory */ }
+    }
+    return respond(ctx, res, r);
   },
 };

package/workspace/lib/routes-notes.js

@@ -100,6 +100,7 @@ const notesCapture = require('./notes-capture.js');
 const notesRepo = require('./notes-repo.js');
 const notesAudio = require('./notes-audio.js');
 const notesScreen = require('./notes-screen.js');
+const jevScreen = require('./jev-screen.js');
 const notesEcho = require('./notes-echo.js');
 const notesPolish = require('./notes-polish.js');
 const notesFinal = require('./notes-final.js');
@@ -135,12 +136,28 @@ function enrich(ctx, id, added, kind = 'lines') {
 }
 function gatesFor(ctx, root) {
   const dir = ctx.runtimeDir;
-  if (!root) return { root: null, exclude: [], ask: null, check: false, key: null, askOpts: {} };
+  if (!root) return { root: null, exclude: [], ask: null, askImage: null, check: false, key: null, askOpts: {} };
   const repo = tsSettings.getRepo(dir, root);
   const sw = jevNotes.getSwitch(dir, root);
   const key = tsSettings.getKey(dir);
   const snd = jevNotes.senderFor(key, { consent: repo.consent, jev: sw.jev, check: sw.check }, typeof ctx.jevModelOpts === 'function' ? ctx.jevModelOpts(root) : {});
-  return { root, exclude: repo.exclude, ask: snd.ask, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
+  return { root, exclude: repo.exclude, ask: snd.ask, askImage: snd.askImage, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
+}
+/** The repository whose gates hold for Jev looking at a note's shots: the note's own, or for a note bound to no repository
+ * (most past meetings) the first repository where "notes may use Jev" is on and the PM gave consent. */
+function shotRootOf(ctx, note) {
+  const w = note.ws && typeof ctx.getWs === 'function' ? ctx.getWs(note.ws) : null;
+  if (w && w.root) return w.root;
+  return jevNotes.onRoots(ctx.runtimeDir).find((r) => tsSettings.getRepo(ctx.runtimeDir, r).consent) || null;
+}
+/** Jev looks at the note's shots it has not seen (MpJ), in the background, when the repository's gates let notes use Jev.
+ * Opening a past meeting (GET /api/notes/one, GET /api/meeting-replay) starts it, so old captures are cut to the slide too. */
+function lookAtShots(ctx, id) {
+  const note = stillOpen(ctx.runtimeDir, id);
+  if (!note) return null;
+  const g = gatesFor(ctx, shotRootOf(ctx, note));
+  if (!g.askImage) return null;
+  return jevScreen.run({ runtimeDir: ctx.runtimeDir, id, g });
 }
 const stillOpen = (dir, id) => { const r = notes.read(dir, id); return r.ok && !r.note.private ? r.note : null; };
 /** Jev's label (when the label gates hold), then for a checkable item the closest repository passage and Jev's comparison
@@ -798,6 +815,8 @@ async function handle(req, res, url, ctx) {
     if (r.ok) {
       r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null }; r.recording = notesAudio.info(dir, nid); if (r.recording) r.recording = { ...r.recording, cleaned: notesAudio.hasClean(dir, nid) };
       r.screen = { frames: r.note.private ? [] : notesScreen.list(dir, nid), aside: r.note.private ? 0 : notesScreen.asideCount(dir, nid) };
+      // shots Jev has not looked at yet (kept before Jev was switched on, or while it could not be reached): asked now, in the background
+      if (!r.note.private && r.screen.frames.some((f) => !f.jev)) { try { lookAtShots(ctx, nid); } catch { /* advisory */ } }
       if (!Array.isArray(r.note.bullets)) r.note.bullets = [];
       r.bullets_state = bulletsState(ctx, r.note);
       // where the note sits in its meeting series, and what changed since the meeting before (c3-notes-series)
@@ -1027,7 +1046,9 @@ async function handle(req, res, url, ctx) {
     if (!own.ok) return done(own);
     if (typeof body.t !== 'number' || !Number.isFinite(body.t) || body.t < 0) return done({ ok: false, status: 400, error: 'a screenshot needs its meeting time' });
     if (typeof body.img !== 'string' || !body.img) return done({ ok: false, status: 400, error: 'there is no picture to keep' });
-    return done(notesScreen.add(dir, { id, t: body.t, buf: Buffer.from(body.img, 'base64'), w: body.w, h: body.h, why: body.why, surface: body.surface }));
+    const kept = notesScreen.add(dir, { id, t: body.t, buf: Buffer.from(body.img, 'base64'), w: body.w, h: body.h, why: body.why, surface: body.surface });
+    if (kept.ok) { try { lookAtShots(ctx, id); } catch { /* Jev is advisory: the shot is kept either way */ } }
+    return done(kept);
   }
   if (p === '/api/notes/screen-aside') {
     const r = notes.read(dir, id);
@@ -1199,6 +1220,6 @@ function startAgent(ctx, dir, id, w) {
   return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
+module.exports = { prefixes, handle, lookAtShots, shotRootOf, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
   __resetResume: () => { resumedFor = null; },
   __idle: () => Promise.all([transcriber ? transcriber.idle() : null, finalRunner ? finalRunner.idle() : null, ...chains.values()]) };

package/workspace/lib/typesafe.js

@@ -81,7 +81,7 @@ function validKey(key) {
   return typeof key === 'string' && key.length >= 8 && key.length <= 512 && !/[\s\u0000-\u001f\u007f]/.test(key);
 }
 
-function once({ key, body, timeoutMs, ep = endpoint() }) {
+function once({ key, body, timeoutMs, ep = endpoint(), headers: extra = null }) {
   const mod = ep.protocol === 'http:' ? http : https;
   const payload = Buffer.from(body, 'utf8');
   return new Promise((resolve) => {
@@ -91,7 +91,7 @@ function once({ key, body, timeoutMs, ep = endpoint() }) {
       protocol: ep.protocol, hostname: ep.hostname, port: ep.port, path: PATH, method: 'POST',
       headers: {
         'Content-Type': 'application/json', 'Content-Length': payload.length,
-        ...(key ? { Authorization: 'Bearer ' + key } : {}), 'User-Agent': 'pmos-workspace',
+        ...(key ? { Authorization: 'Bearer ' + key } : {}), 'User-Agent': 'pmos-workspace', ...(extra || {}),
       },
       timeout: timeoutMs,
     }, (res) => {
@@ -135,10 +135,10 @@ function once({ key, body, timeoutMs, ep = endpoint() }) {
  * @returns {Promise<{ok:true, model, answers, usage}|{ok:false, reason, status?, requested:boolean}>}
  *   `requested` says whether a request left this process, so a caller can tell a refusal from a failure.
  */
-async function send({ key, body, ep, timeoutMs, retries, backoffMs }) {
+async function send({ key, body, ep, timeoutMs, retries, backoffMs, headers = null }) {
   let last = null;
   for (let attempt = 0; attempt <= retries; attempt++) {
-    last = await once({ key, body, timeoutMs, ep });
+    last = await once({ key, body, timeoutMs, ep, headers });
     if (last.ok) return { ...last, requested: true };
     if (!(last.status === 0 || retryable(last.status)) || attempt === retries) break;
     await sleep(backoffMs * Math.pow(2, attempt));
@@ -182,4 +182,70 @@ async function ask({ key, state, questions, model = DEFAULT_MODEL, timeoutMs = 3
   return l.ok ? { ...l, fallback: true, hosted_reason: r.reason } : { ...r, reason: r.reason + '; ' + l.reason };
 }
 
-module.exports = { ask, validKey, configureLocal, localTarget, validPort, validBackend, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, LOCAL_HOST, LOCAL_KEY, BACKENDS, __setEndpointForTests };
+/* ── images (docs.typesafe.ai/images.md, read 2026-11-04) ──────────────────────────────────────────────────────────────
+ * Jev 1.13 and 1.14 take still PNG or JPEG images; a Box question needs Jev 1.14 (jev-latest). Each request that holds an image
+ * or a Box question carries the header `TypeSafe-Danger-Zone-Images: true` (the feature is a preview). The image goes in the
+ * top-level `assets` map under a reference, and the reference is written in `state` where the image belongs. The service does
+ * not resize: each side must be 280 to 1568 px and the picture 78,400 to 2,458,624 px, so a caller sends a picture in range.
+ * The local servers (Winnow, Laya) take text only, so an image is never asked locally. */
+const IMAGE_HEADER = { 'TypeSafe-Danger-Zone-Images': 'true' };
+const IMAGE_SIDE = { min: 280, max: 1568 };
+const IMAGE_PIXELS = { min: 78400, max: 2458624 };
+const MAX_IMAGE_BYTES = 16 * 1024 * 1024;
+
+/** The width and height a PNG or JPEG file says it has, from its own bytes → { format: 'png'|'jpg', w, h } | null. */
+function imageSize(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 24) return null;
+  if (buf.readUInt32BE(0) === 0x89504e47 && buf.toString('latin1', 12, 16) === 'IHDR') return { format: 'png', w: buf.readUInt32BE(16), h: buf.readUInt32BE(20) };
+  if (buf[0] !== 0xff || buf[1] !== 0xd8) return null;
+  let i = 2;
+  while (i + 9 < buf.length) {
+    if (buf[i] !== 0xff) { i++; continue; }
+    const m = buf[i + 1];
+    if (m === 0xff) { i++; continue; }
+    if (m === 0xd8 || m === 0x01 || (m >= 0xd0 && m <= 0xd7)) { i += 2; continue; }
+    const len = buf.readUInt16BE(i + 2);
+    // a start-of-frame marker (C0–CF, but not C4 DHT, C8 JPG, CC DAC) holds the height then the width
+    if (m >= 0xc0 && m <= 0xcf && m !== 0xc4 && m !== 0xc8 && m !== 0xcc) return { format: 'jpg', w: buf.readUInt16BE(i + 7), h: buf.readUInt16BE(i + 5) };
+    i += 2 + len;
+  }
+  return null;
+}
+/** Why Jev would refuse this picture, or null when it is in range. */
+function imageRefusal(size, bytes) {
+  if (!size) return 'the picture is not a PNG or a JPEG';
+  if (bytes > MAX_IMAGE_BYTES) return 'the picture is larger than 16 MB';
+  const { w, h } = size;
+  if (w < IMAGE_SIDE.min || h < IMAGE_SIDE.min || w > IMAGE_SIDE.max || h > IMAGE_SIDE.max) return `the picture is ${w} × ${h} px; Jev takes 280 to 1568 px a side`;
+  if (w * h < IMAGE_PIXELS.min || w * h > IMAGE_PIXELS.max) return `the picture has ${w * h} px; Jev takes 78,400 to 2,458,624`;
+  return null;
+}
+
+/**
+ * Ask Jev typed questions about one picture.
+ *
+ * @param {object} a
+ * @param {string} a.key        the API key. Required; no key (or only the local handle) means no request.
+ * @param {Buffer} a.image      a PNG or JPEG file, in Jev's size range (imageRefusal says why not).
+ * @param {string} a.name       how `state` and the questions call the picture, e.g. 'capture'. Letters only.
+ * @param {object} a.questions  { name: { type: 'noul'|'score'|'choice'|'box', instructions, criteria? } }
+ * @param {string} [a.text]     words to send with the picture (no secret: the caller scans them).
+ * @returns {Promise<{ok:true, model, answers, usage}|{ok:false, reason, status?, requested:boolean}>}
+ */
+async function askImage({ key, image, name = 'capture', questions, text = '', model = DEFAULT_MODEL, timeoutMs = 30000, retries = 2, backoffMs = 600 } = {}) {
+  if (!validKey(key) || key === LOCAL_KEY) return { ok: false, requested: false, reason: key === LOCAL_KEY ? 'the local model takes no pictures' : 'no TypeSafe key is set' };
+  const size = imageSize(image);
+  const refused = imageRefusal(size, image ? image.length : 0);
+  if (refused) return { ok: false, requested: false, reason: refused };
+  if (!/^[a-z]{1,32}$/.test(name)) return { ok: false, requested: false, reason: 'the picture needs a short name' };
+  const names = questions && typeof questions === 'object' ? Object.keys(questions) : [];
+  if (!names.length || names.length > MAX_QUESTIONS) return { ok: false, requested: false, reason: `between 1 and ${MAX_QUESTIONS} questions are required` };
+  // the reference is random, so no words in the questions or the text can match it by chance (images.md "References")
+  const ref = require('crypto').randomBytes(6).toString('hex') + '-' + name;
+  const words = String(text || '').slice(0, 4000);
+  const body = JSON.stringify({ model, state: { [name]: ref, ...(words ? { words } : {}) },
+    assets: { [ref]: { type: 'image', format: size.format, data_base64: image.toString('base64') } }, questions });
+  return send({ key, body, ep: endpoint(), timeoutMs, retries, backoffMs, headers: IMAGE_HEADER });
+}
+
+module.exports = { ask, askImage, imageSize, imageRefusal, IMAGE_SIDE, IMAGE_PIXELS, IMAGE_HEADER, validKey, configureLocal, localTarget, validPort, validBackend, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, LOCAL_HOST, LOCAL_KEY, BACKENDS, __setEndpointForTests };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/cozy-vw.css

@@ -261,6 +261,7 @@
 .vz-words .vz-eye { align-self: flex-start; padding: 3px 8px; border-radius: 4px; background: color-mix(in oklab, var(--cz-c-ffffff) 18%, transparent); font-size: 9px; font-weight: 700; letter-spacing: .06em; text-transform: uppercase; }
 .vz-fr { position: absolute; inset: 0; overflow: hidden; }
 .vz-fr iframe { width: 1280px; height: 720px; border: 0; transform-origin: 0 0; transform: scale(var(--rp-scale, .4)); pointer-events: none; background: var(--cz-c-ffffff); }
+.vz-fr.vz-live iframe { pointer-events: auto; }   /* a slide with CSS-only controls (report library timeline, actions): premium-report-read.js slideCard */
 .vz-snav { display: flex; align-items: center; gap: 8px; }
 .vz-snav > b { font-size: var(--fs-label); font-weight: var(--fw-strong); line-height: var(--lh-label); }
 .vz-snav > span:not(.vz-sp) { font-size: var(--fs-meta); color: var(--cz-ink3); line-height: var(--lh-meta); }

package/workspace/public/pm/notes-screen-capture.js

@@ -23,7 +23,7 @@
  *     pictures of the last RING_MS (20 s) in memory for this, because a line is transcribed some seconds after it is said.
  *   - highlight: the PM's Highlight keeps the picture on screen at that moment.
  *   A picture the last kept shot already shows is never kept again, whatever the reason. Each shot carries why it was kept.
- * The shot is a JPEG of the frame at most MAX_W px wide. It is posted with the meeting time, the note and the capture token, so
+ * The shot is a JPEG of the frame at most MAX_SIDE px on its longer side: 1568 is the most Jev for images reads (lib/jev-screen.js). It is posted with the meeting time, the note and the capture token, so
  * the server keeps it beside the transcript and refuses a second tab (lib/notes-screen.js).
  *
  * WHAT IT NEVER DOES. It sends a shot only to this workspace's own server (`post`), never anywhere else.
@@ -32,7 +32,7 @@ import { bind, unbind } from './notes-shots.js';
 
 const SMALL_W = 64;
 const SMALL_H = 36;
-const MAX_W = 1600;
+const MAX_SIDE = 1568;
 const QUALITY = 0.72;
 
 export function changed(prev, cur, { pixel = 24, share = 0.02 } = {}) {
@@ -87,8 +87,9 @@ export function startScreen({ track, id, cap, clock, post, every = 2000, slowGap
   const s = { count: 0, lost: 0, stopped: false, paused: false, last: null, lastAt: 0, prev: null, moving: 0, still: 0, run: 0, ring: [], kept: new Map(), cues: [], heard: new Set(), chain: Promise.resolve(), timer: null };
 
   const snap = async (t, grey) => {
-    const w = Math.min(MAX_W, video.videoWidth);
-    const h = Math.round(video.videoHeight * (w / video.videoWidth));
+    const k = Math.min(1, MAX_SIDE / video.videoWidth, MAX_SIDE / video.videoHeight);
+    const w = Math.round(video.videoWidth * k);
+    const h = Math.round(video.videoHeight * k);
     big.width = w; big.height = h;
     big.getContext('2d').drawImage(video, 0, 0, w, h);
     const blob = await new Promise((res) => big.toBlob(res, 'image/jpeg', QUALITY));

package/workspace/public/pm/premium-report-read.js

@@ -163,11 +163,32 @@ export function splitRender(html) {
   return { style, slides, body: d.body.innerHTML };
 }
 const href = (f) => new URL('./' + f, import.meta.url).href;
+/* The workspace face inside the frame (batch 27 item 14, report library B2). The frame's origin is opaque, so a font file it asks for is refused
+ * by CORS; the page reads the face once (same origin) and hands it to the frame as a data: font. Until it is read the slide shows the fallback face,
+ * then it is drawn again. Only a render that names the face takes it. */
+const FACE = { css: '', state: '' };
+function faceCss(style) {
+  if (!/Plus Jakarta Sans/.test(style)) return '';
+  if (FACE.state === '' && typeof fetch === 'function' && typeof FileReader === 'function') {
+    FACE.state = 'reading';
+    fetch('/vendor/plus-jakarta-sans-var.woff2').then((r) => (r.ok ? r.blob() : null)).then((b) => {
+      if (!b) { FACE.state = 'none'; return; }
+      const fr = new FileReader();
+      fr.onload = () => { FACE.css = '@font-face{font-family:"Plus Jakarta Sans";font-style:normal;font-weight:200 800;font-display:block;src:url(' + fr.result + ') format("woff2")}'; FACE.state = 'ready'; if (R) draw(); };
+      fr.onerror = () => { FACE.state = 'none'; };
+      fr.readAsDataURL(b);
+    }).catch(() => { FACE.state = 'none'; });
+  }
+  return FACE.css;
+}
 function frameDoc(style, inner, cls) {
   return '<!doctype html><html lang="en"><head><meta charset="utf-8"><link rel="stylesheet" href="' + esc(href('tokens.css')) + '"><link rel="stylesheet" href="' + esc(href('premium-report-frame.css')) + '">'
-    + '<style>' + String(style || '').replace(/<\/style/gi, '<\\/style') + '</style></head><body class="pmos-frame ' + cls + '">' + String(inner || '') + '</body></html>';
+    + '<style>' + faceCss(String(style || '')) + String(style || '').replace(/<\/style/gi, '<\\/style') + '</style></head><body class="pmos-frame ' + cls + '">' + String(inner || '') + '</body></html>';
 }
-const frame = (style, inner, cls, title) => `<iframe sandbox="" tabindex="-1" title="${esc(title)}" srcdoc="${esc(frameDoc(style, inner, cls))}"></iframe>`;
+/* A slide with CSS-only controls (data-pmos-live: the library's timeline span and filter, the ticked actions) takes the pointer and the keyboard in
+ * the big view and in Present; a thumbnail never does. Nothing in the frame runs: its sandbox stays empty. */
+const frame = (style, inner, cls, title, live) => `<iframe sandbox=""${live ? '' : ' tabindex="-1"'} title="${esc(title)}" srcdoc="${esc(frameDoc(style, inner, cls))}"></iframe>`;
+const LIVE_RE = /<section\b[^>]*\bdata-pmos-live=/;
 
 /* ── what is shown ── */
 function slides() {
@@ -210,7 +231,7 @@ export function headFigure(w) {
 }
 /** One slide: a designed frame, the title slide or a section's words. */
 export function slideCard(s, mini) {
-  if (s.k === 'frame') return `<span class="vz-fr">${frame(s.css, s.html, 'pmos-one', s.h)}</span>`;
+  if (s.k === 'frame') { const live = !mini && LIVE_RE.test(s.html); return `<span class="vz-fr${live ? ' vz-live' : ''}">${frame(s.css, s.html, 'pmos-one', s.h, live)}</span>`; }
   if (s.k === 'title') return `<span class="vz-words vz-title"><span class="vz-eye">${esc(s.eye || (R && R.audience) || 'Report')}</span><h4 data-ed="title">${esc(s.title || s.h)}${s.acc ? ` <em class="vz-acc">${esc(s.acc)}</em>` : ''}</h4>${mini ? '' : `${s.sub ? `<b class="vz-tsub">${esc(s.sub)}</b>` : ''}<p>${esc(s.t || '')}</p>`}</span>${!mini && s.fig ? `<span class="vz-tfig"><i class="vz-tdot" aria-hidden="true"></i><span><b>${esc(s.fig.v)}</b>${s.fig.cap ? `<small>${esc(s.fig.cap)}</small>` : ''}</span></span>` : ''}`;
   return `<span class="vz-words"><h4>${esc(s.h)}</h4>${mini ? '' : s.html}</span>`;
 }

package/workspace/public/pm/premium-vw-mtg.js

@@ -644,6 +644,21 @@ async function load(me, quiet) {
     edits: pts && pts.ok ? pts.edits || {} : (me.D && me.D.edits) || {}, lessons: pts && pts.ok ? pts.lessons || [] : (me.D && me.D.lessons) || [],
     terms: pts && pts.ok ? pts.terms || [] : (me.D && me.D.terms) || [] };
   draw(me);
+  if (rp && rp.ok && rp.jev_running) jevWatch(me, n.id);
+}
+/** Jev is cutting a past meeting's captures to the slide (MpJ): read the replay again every few seconds until it ends, so the
+ * crops show on this open, not the next. At most JEV_TRIES reads; the page draws the shots it has meanwhile. */
+const JEV_EVERY = 4000, JEV_TRIES = 45;
+function jevWatch(me, id, tries = 0) {
+  clearTimeout(me.jevT);
+  me.jevT = setTimeout(async () => {
+    if (MT !== me || !me.D || !me.n || me.n.id !== id) return;
+    const rp = await pmGet('/api/meeting-replay?' + q({ note: id }));
+    if (MT !== me || !me.D || !(rp && rp.ok)) return;
+    const rep = replayModel(rp); rep.raw = rp.keys || [];
+    me.D.rep = rep; draw(me);
+    if (rp.jev_running && tries + 1 < JEV_TRIES) jevWatch(me, id, tries + 1);
+  }, JEV_EVERY);
 }
 async function keyOf(text) {
   try {

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

@@ -1228,8 +1228,8 @@ function openSettings(ctx, n) {
       const csw = field({ label: 'Check notes against this repository with Jev', kind: 'check', value: !!(j && j.check), onCommit: (v) => setSwitch(ctx, { check: v }).then(() => { h.close(); openSettings(ctx, n); }), attrs: { 'data-nt-sw-check': '' } });
       parts.push(el('div', { class: 'nt-set' }, el('div', { class: 'nt-set__head' }, 'Jev'), jsw, csw,
         el('p', { class: 'nt-hint', 'data-nt-gates': '' }, j && j.paused ? j.paused : j && j.sentence ? j.sentence + ' Lines get the local label and the local repository match.'
-          : j && j.check_open ? 'Each line and, for a captured line, one repository passage go to TypeSafe. Audio, names and private notes never do.'
-            : j && j.label_open ? 'Each line goes to TypeSafe for its label. Audio, names and private notes never do.' : 'Off. Lines get the local label and the local repository match.')));
+          : j && j.check_open ? 'Each line and, for a captured line, one repository passage go to TypeSafe, and each screen capture so it can be cut to the slide. Audio, names and private notes never do.'
+            : j && j.label_open ? 'Each line goes to TypeSafe for its label, and each screen capture so it can be cut to the slide. Audio, names and private notes never do.' : 'Off. Lines get the local label and the local repository match.')));
     }
     parts.push(el('div', { class: 'nt-set' }, el('div', { class: 'nt-set__head' }, 'This note'),
       n.private ? el('p', { class: 'nt-hint' }, 'Private: it is not recorded and nothing from it goes to Jev or to any agent.') : null,

package/workspace/skills/report-write.skill

@@ -36,9 +36,10 @@ Procedure:
    - 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.
    - `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.
-7. Read what `pmos report write` prints. A refusal names the check: fix the report and run it again. When it passes, it writes `<slot>.md` and `<slot>.checks.json`; the deck, the PDF and the PowerPoint are drawn from the same model, in the report's saved look.
+7. Read what `pmos report write` prints. A refusal names the check: fix the report and run it again. When it passes, it writes `<slot>.md` and `<slot>.checks.json`; the deck, the PDF and the PowerPoint are drawn from the same model, in the report library's frame.
 8. Learn. When the PM's change in the chat is about the words (shorter, plainer, another tone) and it would apply to every issue, keep it: `pmos report rule <id> add wording "<the rule, one line>"`. When the PM removes a part beyond the ask, `pmos report rule <id> add off <part>`. Then change report.json and run `pmos report write` again. A change to a number is a change to a reading: read the source again and file it.
 9. Finish by saying in one line where the draft is and how many readings, findings and gaps it has. Do not commit; the PM's Sync carries the files.

package/workspace/test-files.json

@@ -76,6 +76,7 @@
     "jev-categorize.test.js",
     "jev-status.test.js",
     "jev-route.test.js",
+    "jev-screen.test.js",
     "repo-watch.test.js",
     "markdown.test.mjs",
     "start-policy.test.js",

package/workspace/test-lists/report-slides.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "Batch 27 item 14, the report library: the B2 frame and its 23 layouts, the templates, the engine deck in that frame, the document and PowerPoint lines, and pmos report library (lib/report-slides.js, lib/report-library.js). Pure.",
+  "modules": [
+    "report-slides.test.js"
+  ],
+  "seconds": {
+    "report-slides.test.js": 2
+  }
+}